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

@@ -0,0 +1,213 @@
+/**
+ * Tests for Python 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 registerPython from '../../../Syntax/Language/python.js';
+import {
+	assertToken,
+	assertTokenType,
+	assertTokenCount,
+	getMatchText
+} from '../../helpers/ast-matcher.js';
+test('Python language can be registered', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'python');
+});
+test('Python can match keywords', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'def foo():\n    return True';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'keyword', 'def');
+	assertToken(code, matches, 'keyword', 'return');
+});
+test('Python can match builtin functions', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'len(list)';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'builtin', 'len');
+	assertToken(code, matches, 'builtin', 'list');
+});
+test('Python can match decorators', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = '@property\ndef foo(self):\n    pass';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'decorator', '@property');
+});
+test('Python can match constants', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'x = True\ny = False\nz = None\nself.value = 42';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'constant', 'True');
+	assertToken(code, matches, 'constant', 'False');
+	assertToken(code, matches, 'constant', 'None');
+	assertToken(code, matches, 'constant', 'self');
+});
+test('Python can match single-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = "s = 'hello world'";
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', "'hello world'");
+});
+test('Python can match double-quoted strings', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 's = "hello world"';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'string', '"hello world"');
+});
+test('Python can match triple-quoted strings (docstrings)', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = '"""This is a docstring"""';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'comment', '"""This is a docstring"""');
+});
+test('Python can match hash comments', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = '# This is a comment\nx = 1';
+	const matches = await language.getMatches(syntax, code);
+	const commentMatch = assertTokenType(matches, 'comment');
+	const text = getMatchText(code, commentMatch);
+	assert.ok(text.startsWith('#'));
+});
+test('Python can match operators', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'x += y * 2';
+	const matches = await language.getMatches(syntax, code);
+	assertTokenCount(matches, 'operator', 2); // At least += and *
+});
+test('Python can match numbers', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'x = 42\ny = 3.14\nz = 0xFF';
+	const matches = await language.getMatches(syntax, code);
+	const constants = assertTokenCount(matches, 'constant', 3);
+	const texts = constants.map(m => getMatchText(code, m));
+	assert.ok(texts.includes('42'));
+	assert.ok(texts.includes('3.14'));
+	assert.ok(texts.includes('0xFF'));
+});
+test('Python can match CamelCase class names', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'class MyClass:\n    pass';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'type', 'MyClass');
+});
+test('Python can match function calls', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'result = my_function(arg)';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'function', 'my_function');
+});
+test('Python can process code to HTML', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'def foo():\n    return True';
+	const html = await language.process(syntax, code);
+	assert.ok(html.innerHTML.includes('keyword'));
+	assert.ok(html.innerHTML.includes('def'));
+	assert.ok(html.innerHTML.includes('return'));
+});
+test('Python can build a syntax tree', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'x = 42';
+	const tree = await language.buildTree(syntax, code, 0);
+	assert.ok(tree);
+	assert.strictEqual(tree.offset, 0);
+	assert.strictEqual(tree.length, code.length);
+});
+test('Python creates documentation links for functions', async () => {
+	const syntax = new Syntax();
+	registerPython(syntax);
+	const language = await syntax.getLanguage('python');
+	const code = 'len(list)';
+	const html = await language.process(syntax, code);
+	// Should have links to Python documentation
+	const links = html.querySelectorAll('a.builtin');
+	assert.strictEqual(links.length, 2);
+	assert.ok(links[0].href.includes('docs.python.org'));
+	assert.ok(links[0].href.includes('len'));
+	assert.strictEqual(links[0].textContent, 'len');
+});

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

@@ -0,0 +1,70 @@
+import Syntax from '../../../Syntax.js';
+import registerRuby from '../../../Syntax/Language/ruby.js';
+import {strictEqual} from 'node:assert';
+import test from 'node:test';
+async function getTypesFor(code) {
+	const syntax = new Syntax();
+	registerRuby(syntax);
+	const language = await syntax.getLanguage('ruby');
+	const matches = await language.getMatches(syntax, code);
+	return matches.map(m => m.expression.type);
+}
+test('Ruby: keywords highlighted', async () => {
+	const types = await getTypesFor('def method\nend');
+	strictEqual(types.includes('keyword'), true);
+});
+test('Ruby: values/constants', async () => {
+	const types = await getTypesFor('self true false nil super');
+	strictEqual(types.filter(t => t === 'constant').length >= 3, true);
+});
+test('Ruby: access modifiers', async () => {
+	const types = await getTypesFor('private\nprotected\npublic');
+	strictEqual(types.includes('access'), true);
+});
+test('Ruby: variables', async () => {
+	const types = await getTypesFor('@@class_var @instance $global');
+	strictEqual(types.includes('variable'), true);
+});
+test('Ruby: operators', async () => {
+	const types = await getTypesFor('a + b - c * d / e');
+	strictEqual(types.includes('operator'), true);
+});
+test('Ruby: strings', async () => {
+	const types = await getTypesFor('\'single\' "double"');
+	strictEqual(types.filter(t => t === 'string').length >= 2, true);
+});
+test('Ruby: numbers', async () => {
+	const types = await getTypesFor('0xFF 123 3.14');
+	strictEqual(types.filter(t => t === 'constant').length >= 2, true);
+});
+test('Ruby: comments and links', async () => {
+	const types = await getTypesFor('# comment http://example.com');
+	strictEqual(types.includes('comment'), true);
+	strictEqual(types.includes('href'), true);
+});
+test('Ruby: regex literal', async () => {
+	const types = await getTypesFor('/foo.+bar/i');
+	strictEqual(types.includes('constant'), true);
+});
+test('Ruby: symbols', async () => {
+	const types1 = await getTypesFor(':symbol');
+	strictEqual(types1.includes('constant'), true);
+	const types2 = await getTypesFor('::symbol');
+	strictEqual(types2.includes('constant'), false);
+});
+test('Ruby: function detection', async () => {
+	const types = await getTypesFor('def compute\nend\nobject.method');
+	strictEqual(types.includes('function'), true);
+});

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

@@ -0,0 +1,75 @@
+import Syntax from '../../../Syntax.js';
+import registerScala from '../../../Syntax/Language/scala.js';
+import registerXML from '../../../Syntax/Language/xml.js';
+import {strictEqual, ok} from 'node:assert';
+import test from 'node:test';
+async function getLanguage() {
+	const syntax = new Syntax();
+	registerXML(syntax);
+	registerScala(syntax);
+	return await syntax.getLanguage('scala');
+}
+function typesFrom(matches) {
+	return matches.map(m => m.expression.type);
+}
+test('Scala: keywords highlighted', async () => {
+	const language = await getLanguage();
+	const code =
+		'object App extends App { def run(): Unit = if (true) return else for (x <- xs) yield x }';
+	const matches = await language.getMatches(Syntax.default, code);
+	const types = typesFrom(matches);
+	ok(types.includes('keyword'));
+});
+test('Scala: operators highlighted', async () => {
+	const language = await getLanguage();
+	const code = 'xs.map(x => x: Int) @annot #hash';
+	const matches = await language.getMatches(Syntax.default, code);
+	const operators = matches.filter(m => m.expression.type === 'operator');
+	ok(operators.length > 0);
+});
+test('Scala: constants highlighted', async () => {
+	const language = await getLanguage();
+	const code = 'this == null || true && !false';
+	const matches = await language.getMatches(Syntax.default, code);
+	const constants = matches.filter(m => m.expression.type === 'constant');
+	ok(constants.length >= 3);
+});
+test('Scala: triple and double quoted strings', async () => {
+	const language = await getLanguage();
+	const code = 'val a = "hello"; val b = """multi\nline"""';
+	const matches = await language.getMatches(Syntax.default, code);
+	const strings = matches.filter(m => m.expression.type === 'string');
+	ok(strings.length >= 2);
+});
+test('Scala: function names', async () => {
+	const language = await getLanguage();
+	const code = 'def compute(x: Int) = x + 1; value.toString';
+	const matches = await language.getMatches(Syntax.default, code);
+	const functions = matches.filter(m => m.expression.type === 'function');
+	ok(functions.length >= 2);
+});
+test('Scala: types and c-style function calls', async () => {
+	const language = await getLanguage();
+	const code = 'val x: MyType = MyType(1)';
+	const matches = await language.getMatches(Syntax.default, code);
+	const types = matches.filter(m => m.expression.type === 'type');
+	const functions = matches.filter(m => m.expression.type === 'function');
+	ok(types.length >= 1);
+	ok(functions.length >= 1);
+});
+test('Scala: comments', async () => {
+	const language = await getLanguage();
+	const code = '/* block */ // line';
+	const matches = await language.getMatches(Syntax.default, code);
+	const comments = matches.filter(m => m.expression.type === 'comment');
+	ok(comments.length >= 2);
+});

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

@@ -0,0 +1,223 @@
+/**
+ * Tests for Smalltalk 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('Smalltalk language can be registered', async () => {
+	const language = await syntax.getResource('smalltalk');
+	assert.ok(language);
+	assert.equal(language.name, 'smalltalk');
+});
+test('Smalltalk can match self keyword', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'self doSomething');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'self'));
+});
+test('Smalltalk can match super keyword', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'super initialize');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'super'));
+});
+test('Smalltalk can match true and false', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'true & false');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'true'));
+	assert.ok(constants.some(m => m.value === 'false'));
+});
+test('Smalltalk can match nil keyword', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'x := nil');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'nil'));
+});
+test('Smalltalk can match bracket operators', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, '[x + 1]');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '['));
+	assert.ok(operators.some(m => m.value === ']'));
+});
+test('Smalltalk can match pipe operator', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, '| temp |');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '|'));
+});
+test('Smalltalk can match assignment operator', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'x := 42');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === ':='));
+});
+test('Smalltalk can match statement separator', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'x := 1. y := 2');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '.'));
+});
+test('Smalltalk can match unary message selectors', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'self initialize');
+	// Unary messages are just identifiers, not highlighted specially
+	assert.ok(matches.length > 0);
+});
+test('Smalltalk can match keyword message selectors', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'object at: key put: value');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'at:'));
+	assert.ok(functions.some(m => m.value === 'put:'));
+});
+test('Smalltalk can match method definition selectors', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'setName: aName age: anAge');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'setName:'));
+	assert.ok(functions.some(m => m.value === 'age:'));
+});
+test('Smalltalk can match CamelCase types', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'OrderedCollection new');
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'OrderedCollection'));
+});
+test('Smalltalk can match class names', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'Array with: String');
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'Array'));
+	assert.ok(types.some(m => m.value === 'String'));
+});
+test('Smalltalk can match single-quoted strings', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, "'Hello, World!'");
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === "'Hello, World!'"));
+});
+test('Smalltalk can match strings with escaped quotes', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, "'It''s a test'");
+	const strings = matches.filter(m => m.type === 'string');
+	// In Smalltalk, two single quotes represent an escaped quote
+	assert.ok(strings.length > 0);
+});
+test('Smalltalk can match decimal numbers', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'x := 42');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '42'));
+});
+test('Smalltalk can match floating point numbers', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'pi := 3.14159');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '3.14159'));
+});
+test('Smalltalk can match hexadecimal numbers', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, 'color := 0xFF');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '0xFF'));
+});
+test('Smalltalk can match blocks', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, '[x + 1] value');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '['));
+	assert.ok(operators.some(m => m.value === ']'));
+});
+test('Smalltalk can match temporary variable declarations', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const matches = await language.getMatches(syntax, '| temp1 temp2 |');
+	const operators = matches.filter(m => m.type === 'operator');
+	const pipes = operators.filter(m => m.value === '|');
+	assert.equal(pipes.length, 2);
+});
+test('Smalltalk can process method definition', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const code = `initialize
+	super initialize.
+	collection := OrderedCollection new`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'super'));
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'OrderedCollection'));
+});
+test('Smalltalk can process cascade messages', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const code = `stream
+	nextPutAll: 'Hello';
+	space;
+	nextPutAll: 'World'`;
+	const matches = await language.getMatches(syntax, code);
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'nextPutAll:'));
+});
+test('Smalltalk can process complete class method', async () => {
+	const language = await syntax.getResource('smalltalk');
+	const code = `factorial: n
+	| result |
+	result := 1.
+	n > 1 ifTrue: [
+		result := n * (self factorial: n - 1)
+	].
+	^ result`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	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 === ']'));
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'self'));
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'factorial:'));
+	assert.ok(functions.some(m => m.value === 'ifTrue:'));
+});