presently 0.1.0

data/public/_components/@socketry/syntax/test/Syntax/Language/bash-script.js

@@ -0,0 +1,225 @@
+/**
+ * Tests for bash-script and bash-statement language definitions
+ */
+
+import {test} from 'node:test';
+import assert from 'node:assert';
+
+import Syntax from '../../../Syntax.js';
+import register from '../../../Syntax/Language/bash-script.js';
+
+test('bash-script language can be registered', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-script');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'bash-script');
+});
+
+test('bash-statement language can be registered', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'bash-statement');
+});
+
+test('bash-script can highlight operators', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-script');
+
+	const code = 'command1 && command2';
+	const matches = await language.getMatches(syntax, code);
+
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.length > 0);
+	assert.ok(operators.some(m => m.value === '&&'));
+});
+
+test('bash-script can highlight pipe operators', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-script');
+
+	const code = 'cat file | grep pattern';
+	const matches = await language.getMatches(syntax, code);
+
+	const pipe = matches.find(m => m.value === '|' && m.type === 'operator');
+	assert.ok(pipe);
+});
+
+test('bash-script can highlight semicolon separators', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-script');
+
+	const code = 'echo hello; echo world';
+	const matches = await language.getMatches(syntax, code);
+
+	const semicolon = matches.find(m => m.value === ';' && m.type === 'operator');
+	assert.ok(semicolon);
+});
+
+test('bash-statement can highlight keywords', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'if [ $x -eq 1 ]; then echo yes; fi';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.length > 0);
+	assert.ok(keywords.some(m => m.value === 'if'));
+	assert.ok(keywords.some(m => m.value === 'then'));
+	assert.ok(keywords.some(m => m.value === 'fi'));
+});
+
+test('bash-statement can highlight for loops', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'for i in 1 2 3; do echo $i; done';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'for'));
+	assert.ok(keywords.some(m => m.value === 'do'));
+	assert.ok(keywords.some(m => m.value === 'done'));
+});
+
+test('bash-statement can highlight variables', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'echo $HOME';
+	const matches = await language.getMatches(syntax, code);
+
+	const variable = matches.find(m => m.type === 'variable');
+	assert.ok(variable);
+	assert.strictEqual(variable.value, '$HOME');
+});
+
+test('bash-statement can highlight environment variable assignments', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'PATH=/usr/bin';
+	const matches = await language.getMatches(syntax, code);
+
+	// Should recognize variable assignment
+	assert.ok(matches.length > 0);
+});
+
+test('bash-statement can highlight arithmetic expressions', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'result=$((5 + 3))';
+	const matches = await language.getMatches(syntax, code);
+
+	const expression = matches.find(m => m.type === 'expression');
+	assert.ok(expression);
+});
+
+test('bash-statement can highlight command substitution with backticks', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'date=`date +%Y-%m-%d`';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+});
+
+test('bash-statement can highlight single-quoted strings', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = "echo 'hello world'";
+	const matches = await language.getMatches(syntax, code);
+
+	const string = matches.find(m => m.type === 'string');
+	assert.ok(string);
+});
+
+test('bash-statement can highlight double-quoted strings', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'echo "hello world"';
+	const matches = await language.getMatches(syntax, code);
+
+	const string = matches.find(m => m.type === 'string');
+	assert.ok(string);
+});
+
+test('bash-statement can highlight command options', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'ls -la --color=auto';
+	const matches = await language.getMatches(syntax, code);
+
+	const options = matches.filter(m => m.type === 'option');
+	assert.ok(options.length > 0);
+});
+
+test('bash-statement can highlight comments', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = '# This is a comment';
+	const matches = await language.getMatches(syntax, code);
+
+	const comment = matches.find(m => m.type === 'comment');
+	assert.ok(comment);
+});
+
+test('bash-statement can highlight decimal numbers', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'echo 42';
+	const matches = await language.getMatches(syntax, code);
+
+	const number = matches.find(m => m.type === 'constant');
+	assert.ok(number);
+});
+
+test('bash-statement can handle case statements', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'case $var in';
+	const matches = await language.getMatches(syntax, code);
+
+	const keyword = matches.find(m => m.value === 'case' && m.type === 'keyword');
+	assert.ok(keyword);
+});
+
+test('bash-statement can handle function definitions', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('bash-statement');
+
+	const code = 'function myFunc {';
+	const matches = await language.getMatches(syntax, code);
+
+	const keyword = matches.find(
+		m => m.value === 'function' && m.type === 'keyword'
+	);
+	assert.ok(keyword);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/bash.js

@@ -0,0 +1,162 @@
+/**
+ * Tests for bash language definition
+ */
+
+import {test} from 'node:test';
+import assert from 'node:assert';
+
+import Syntax from '../../../Syntax.js';
+import register from '../../../Syntax/Language/bash.js';
+import registerBashScript from '../../../Syntax/Language/bash-script.js';
+
+test('bash language can be registered', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'bash');
+});
+
+test('bash can highlight shell prompts', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ echo hello';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+	assert.strictEqual(matches[0].type, 'prompt');
+});
+
+test('bash can embed bash-script for command execution', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ ls -la';
+	const matches = await language.getMatches(syntax, code);
+
+	// Should find prompt and embedded bash-script execution
+	const hasPrompt = matches.some(m => m.type === 'prompt');
+	assert.ok(hasPrompt);
+});
+
+test('bash can handle multi-line commands', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ echo "line 1"\n$ echo "line 2"';
+	const matches = await language.getMatches(syntax, code);
+
+	// Should find multiple prompts
+	const promptMatches = matches.filter(m => m.type === 'prompt');
+	assert.ok(promptMatches.length >= 2);
+});
+
+test('bash can handle comments in commands', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ echo test  # inline comment';
+	const matches = await language.getMatches(syntax, code);
+
+	// Should have prompt at minimum
+	assert.ok(matches.length > 0);
+});
+
+test('bash can handle strings in commands', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ echo "hello world"';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+});
+
+test('bash can match dollar sign prompts', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ pwd';
+	const matches = await language.getMatches(syntax, code);
+
+	const prompt = matches.find(m => m.type === 'prompt');
+	assert.ok(prompt);
+	assert.strictEqual(prompt.value, '$');
+});
+
+test('bash can match hash prompts for root', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '# whoami';
+	const matches = await language.getMatches(syntax, code);
+
+	// Could be either prompt or comment depending on pattern priority
+	assert.ok(matches.length > 0);
+});
+
+test('bash can handle complex command with options', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ grep -r "pattern" /path/to/dir';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+	const hasPrompt = matches.some(m => m.type === 'prompt');
+	assert.ok(hasPrompt);
+});
+
+test('bash can handle pipes in commands', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ cat file.txt | grep search';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+});
+
+test('bash can handle command substitution', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ echo $(date)';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+});
+
+test('bash can handle variables in commands', async () => {
+	const syntax = new Syntax();
+	registerBashScript(syntax);
+	register(syntax);
+	const language = await syntax.getLanguage('bash');
+
+	const code = '$ echo $PATH';
+	const matches = await language.getMatches(syntax, code);
+
+	assert.ok(matches.length > 0);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/basic.js

@@ -0,0 +1,265 @@
+/**
+ * Tests for BASIC/VB language definition
+ */
+
+import {test} from 'node:test';
+import assert from 'node:assert';
+
+import Syntax from '../../../Syntax.js';
+import register from '../../../Syntax/Language/basic.js';
+
+test('BASIC language can be registered', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'basic');
+});
+
+test('BASIC can be registered with vb alias', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('vb');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'basic');
+});
+
+test('BASIC can highlight keywords', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Dim x As Integer\nIf x > 0 Then\n    Print x\nEnd If';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.length > 0);
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'dim'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'if'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'then'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'end'));
+});
+
+test('BASIC can highlight types', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Dim x As Integer\nDim s As String';
+	const matches = await language.getMatches(syntax, code);
+
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.length > 0);
+	assert.ok(types.some(m => m.value === 'Integer'));
+	assert.ok(types.some(m => m.value === 'String'));
+});
+
+test('BASIC can highlight access modifiers', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Public Sub MyMethod()\nPrivate x As Integer\nEnd Sub';
+	const matches = await language.getMatches(syntax, code);
+
+	const access = matches.filter(m => m.type === 'access');
+	assert.ok(access.length > 0);
+	assert.ok(access.some(m => m.value === 'Public'));
+	assert.ok(access.some(m => m.value === 'Private'));
+});
+
+test('BASIC can highlight constants', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'If x = True Then\n    y = False\nEnd If';
+	const matches = await language.getMatches(syntax, code);
+
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.length > 0);
+	assert.ok(constants.some(m => m.value === 'True'));
+	assert.ok(constants.some(m => m.value === 'False'));
+});
+
+test('BASIC can highlight Me/MyClass/MyBase', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Me.Property = MyBase.Value';
+	const matches = await language.getMatches(syntax, code);
+
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'Me'));
+	assert.ok(constants.some(m => m.value === 'MyBase'));
+});
+
+test('BASIC can highlight operators', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'x = y + z - 5 * 2';
+	const matches = await language.getMatches(syntax, code);
+
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.length > 0);
+	assert.ok(operators.some(m => m.value === '+'));
+	assert.ok(operators.some(m => m.value === '-'));
+	assert.ok(operators.some(m => m.value === '*'));
+});
+
+test('BASIC can highlight VB-style comments', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = "' This is a comment\nDim x As Integer";
+	const matches = await language.getMatches(syntax, code);
+
+	const comment = matches.find(m => m.type === 'comment');
+	assert.ok(comment);
+	assert.ok(comment.value.includes('This is a comment'));
+});
+
+test('BASIC can highlight REM comments', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'REM This is a remark\nDim x As Integer';
+	const matches = await language.getMatches(syntax, code);
+
+	const rem = matches.find(
+		m => m.type === 'keyword' && m.value.toLowerCase() === 'rem'
+	);
+	assert.ok(rem);
+});
+
+test('BASIC can highlight double-quoted strings', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Dim msg As String = "Hello World"';
+	const matches = await language.getMatches(syntax, code);
+
+	const string = matches.find(m => m.type === 'string');
+	assert.ok(string);
+});
+
+test('BASIC can highlight numbers', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Dim x As Integer = 42';
+	const matches = await language.getMatches(syntax, code);
+
+	const number = matches.find(m => m.type === 'constant' && m.value === '42');
+	assert.ok(number);
+});
+
+test('BASIC can highlight Function declarations', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code =
+		'Function Add(a As Integer, b As Integer) As Integer\n    Return a + b\nEnd Function';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'function'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'return'));
+});
+
+test('BASIC can highlight Sub declarations', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Sub MyMethod()\n    Print "Hello"\nEnd Sub';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'sub'));
+});
+
+test('BASIC can highlight For loops', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'For i = 1 To 10\n    Print i\nNext i';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'for'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'to'));
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'next'));
+});
+
+test('BASIC can highlight While loops', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'While x < 10\n    x = x + 1\nEnd While';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'while'));
+});
+
+test('BASIC can highlight Select Case', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Select Case x\n    Case 1\n        Print "One"\nEnd Select';
+	const matches = await language.getMatches(syntax, code);
+
+	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() === 'case'));
+});
+
+test('BASIC can highlight Class declarations', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Public Class MyClass\n    Private x As Integer\nEnd Class';
+	const matches = await language.getMatches(syntax, code);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value.toLowerCase() === 'class'));
+});
+
+test('BASIC can highlight Nothing constant', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'If obj Is Nothing Then';
+	const matches = await language.getMatches(syntax, code);
+
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'Nothing'));
+});
+
+test('BASIC can highlight CamelCase types', async () => {
+	const syntax = new Syntax();
+	register(syntax);
+	const language = await syntax.getLanguage('basic');
+
+	const code = 'Dim customer As CustomerRecord';
+	const matches = await language.getMatches(syntax, code);
+
+	const type = matches.find(
+		m => m.type === 'type' && m.value === 'CustomerRecord'
+	);
+	assert.ok(type);
+});