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

@@ -0,0 +1,163 @@
+/**
+ * Tests for Markdown 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 registerMarkdown from '../../../Syntax/Language/markdown.js';
+import {
+	assertToken,
+	assertTokenType,
+	assertTokenCount,
+	getMatchText
+} from '../../helpers/ast-matcher.js';
+test('Markdown language can be registered', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	assert.ok(language);
+	assert.strictEqual(language.name, 'markdown');
+});
+test('Markdown can match headers', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '# Heading 1';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'heading', '# Heading 1');
+});
+test('Markdown can match bold text', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '**bold text**';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'strong', '**bold text**');
+});
+test('Markdown can match italic text', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '*italic text*';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'emphasis', '*italic text*');
+});
+test('Markdown can match inline code', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '`code here`';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'code', '`code here`');
+});
+test('Markdown can match code blocks', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '```javascript\nconst x = 1;\n```';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'code', '```javascript\nconst x = 1;\n```');
+});
+test('Markdown can match links', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '[text](http://example.com)';
+	const matches = await language.getMatches(syntax, code);
+	// Should match the link text and URL as separate tokens
+	assertToken(code, matches, 'string', 'text');
+	assertToken(code, matches, 'link', 'http://example.com');
+});
+test('Markdown can match images', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '![alt text](image.png)';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'link', '![alt text](image.png)');
+});
+test('Markdown can match blockquotes', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '> This is a quote';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'quote', '> This is a quote');
+});
+test('Markdown can match unordered lists', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '- List item';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'list-marker', '- ');
+});
+test('Markdown can match ordered lists', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = '1. List item';
+	const matches = await language.getMatches(syntax, code);
+	assertToken(code, matches, 'list-marker', '1. ');
+});
+test('Markdown: fenced block followed by inline code does not merge', async () => {
+	const syntax = new Syntax();
+	registerMarkdown(syntax);
+	const language = await syntax.getLanguage('markdown');
+	const code = "```\nfoo\n```\n\n`project`";
+	const matches = await language.getMatches(syntax, code);
+	// Expect a fenced code block token:
+	assertToken(code, matches, 'code', '```\nfoo\n```');
+	// Expect a separate inline code token for `project`:
+	assertToken(code, matches, 'code', '`project`');
+	// Ensure there is no token that incorrectly spans the fence backticks
+	// and the following inline backtick (e.g., "````" boundary merge):
+	const badSpan = matches.find(m =>
+		m.type === 'code' &&
+		code.substring(m.offset, m.offset + m.length).includes('````')
+	);
+	assert.strictEqual(badSpan, undefined);
+});

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

@@ -0,0 +1,267 @@
+/**
+ * Tests for Nginx configuration 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('Nginx language can be registered', async () => {
+	const language = await syntax.getResource('nginx');
+	assert.ok(language);
+	assert.equal(language.name, 'nginx');
+});
+test('nginx: directive matches simple directives', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'listen 80;');
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: directive matches directives with parameters', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'server_name example.com;');
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: directive matches root directive', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'root /var/www/html;');
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: directive matches index directive', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(
+		syntax,
+		'index index.html index.htm;'
+	);
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: directive matches access_log directive', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(
+		syntax,
+		'access_log /var/log/nginx/access.log;'
+	);
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: function matches directive name with web link', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'listen 80;');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.length > 0);
+});
+test('nginx: keyword matches server block', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'server {');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'server'));
+});
+test('nginx: keyword matches http block', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'http {');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'http'));
+});
+test('nginx: keyword matches location block', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'location / {');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'location'));
+});
+test('nginx: keyword matches upstream block', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'upstream backend {');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'upstream'));
+});
+test('nginx: keyword matches events block', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, 'events {');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'events'));
+});
+test('nginx: variable matches simple variable', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, '$host');
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(variables.some(m => m.value.includes('host')));
+});
+test('nginx: variable matches request_uri variable', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, '$request_uri');
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(variables.length > 0);
+});
+test('nginx: variable matches remote_addr variable', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, '$remote_addr');
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(variables.length > 0);
+});
+test('nginx: variable matches http_user_agent variable', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, '$http_user_agent');
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(variables.length > 0);
+});
+test('nginx: variable matches in directive', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(
+		syntax,
+		'return 301 https://$host$request_uri;'
+	);
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(variables.length > 0);
+});
+test('nginx: perlStyleComment matches hash comments', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, '# This is a comment');
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.length > 0);
+});
+test('nginx: singleQuotedString matches single-quoted strings', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, "'text/html'");
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.length > 0);
+});
+test('nginx: doubleQuotedString matches double-quoted strings', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, '"application/json"');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.length > 0);
+});
+test('nginx: complete server block', async () => {
+	const code = `server {
+    listen 80;
+    server_name example.com;
+    root /var/www/html;
+}`;
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, code);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(keywords.length > 0);
+	assert.ok(directives.length > 0);
+});
+test('nginx: location block with proxy_pass', async () => {
+	const code = `location / {
+    proxy_pass http://backend;
+}`;
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, code);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(keywords.length > 0);
+	assert.ok(directives.length > 0);
+});
+test('nginx: rewrite directive with regex', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(
+		syntax,
+		'rewrite ^/old-path(.*)$ /new-path$1 permanent;'
+	);
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: ssl directives', async () => {
+	const code = `ssl_certificate /etc/nginx/ssl/cert.pem;
+ssl_certificate_key /etc/nginx/ssl/key.pem;`;
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, code);
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: gzip directives', async () => {
+	const code = `gzip on;
+gzip_types text/plain text/css application/json;`;
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, code);
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(directives.length > 0);
+});
+test('nginx: upstream with servers', async () => {
+	const code = `upstream backend {
+    server 127.0.0.1:8080;
+    server 127.0.0.1:8081;
+}`;
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, code);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	const directives = matches.filter(m => m.type === 'directive');
+	assert.ok(keywords.length > 0);
+	assert.ok(directives.length > 0);
+});
+test('nginx: add_header directive', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(
+		syntax,
+		'add_header X-Frame-Options "SAMEORIGIN";'
+	);
+	const directives = matches.filter(m => m.type === 'directive');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(directives.length > 0);
+	assert.ok(strings.length > 0);
+});
+test('nginx: try_files directive', async () => {
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(
+		syntax,
+		'try_files $uri $uri/ /index.html;'
+	);
+	const directives = matches.filter(m => m.type === 'directive');
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(directives.length > 0);
+	assert.ok(variables.length > 0);
+});
+test('nginx: if directive with condition', async () => {
+	const code = `if ($request_method = POST) {
+    return 405;
+}`;
+	const language = await syntax.getResource('nginx');
+	const matches = await language.getMatches(syntax, code);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	const variables = matches.filter(m => m.type === 'variable');
+	assert.ok(keywords.length > 0);
+	assert.ok(variables.length > 0);
+});