links-notation 0.11.2 → 0.13.0

package/tests/MixedIndentationModes.test.js

@@ -1,10 +1,10 @@
-import { test, expect } from "bun:test";
-import { Parser } from "../src/Parser.js";
-import { formatLinks } from "../src/Link.js";
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
 
 const parser = new Parser();
 
-test("Hero example - mixed modes - issue #105", () => {
+test('Hero example mixed modes', () => {
   const input = `empInfo
   employees:
     (
@@ -24,14 +24,14 @@ test("Hero example - mixed modes - issue #105", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("empInfo");
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
-  expect(formatted).toContain("Wesley Crusher");
+  expect(formatted).toContain('empInfo');
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
+  expect(formatted).toContain('Wesley Crusher');
 });
 
-test("Hero example - alternative format - issue #105", () => {
+test('Hero example alternative format', () => {
   const input = `empInfo
   (
     employees:
@@ -53,14 +53,14 @@ test("Hero example - alternative format - issue #105", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("empInfo");
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
-  expect(formatted).toContain("Wesley Crusher");
+  expect(formatted).toContain('empInfo');
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
+  expect(formatted).toContain('Wesley Crusher');
 });
 
-test("Hero example - equivalence test - issue #105", () => {
+test('Hero example equivalence', () => {
   const version1 = `empInfo
   employees:
     (
@@ -102,7 +102,7 @@ test("Hero example - equivalence test - issue #105", () => {
   expect(formatted1).toBe(formatted2);
 });
 
-test("Set/object context without colon", () => {
+test('Set context without colon', () => {
   const input = `empInfo
   employees`;
 
@@ -110,11 +110,11 @@ test("Set/object context without colon", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("empInfo");
-  expect(formatted).toContain("employees");
+  expect(formatted).toContain('empInfo');
+  expect(formatted).toContain('employees');
 });
 
-test("Sequence/list context with colon", () => {
+test('Sequence context with colon', () => {
   const input = `employees:
   James Kirk
   Jean-Luc Picard
@@ -125,13 +125,13 @@ test("Sequence/list context with colon", () => {
   expect(result.length).toBeGreaterThan(0);
   expect(result.length).toBe(1);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
-  expect(formatted).toContain("Wesley Crusher");
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
+  expect(formatted).toContain('Wesley Crusher');
 });
 
-test("Sequence context with complex values", () => {
+test('Sequence context with complex values', () => {
   const input = `employees:
   (
     name (James Kirk)
@@ -147,12 +147,12 @@ test("Sequence context with complex values", () => {
   expect(result.length).toBeGreaterThan(0);
   expect(result.length).toBe(1);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
 });
 
-test("Nested set and sequence contexts", () => {
+test('Nested set and sequence contexts', () => {
   const input = `company
   departments:
     engineering
@@ -165,12 +165,12 @@ test("Nested set and sequence contexts", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("company");
-  expect(formatted).toContain("departments:");
-  expect(formatted).toContain("employees:");
+  expect(formatted).toContain('company');
+  expect(formatted).toContain('departments:');
+  expect(formatted).toContain('employees:');
 });
 
-test("Deeply nested mixed modes", () => {
+test('Deeply nested mixed modes', () => {
   const input = `root
   level1
     level2:
@@ -183,6 +183,6 @@ test("Deeply nested mixed modes", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("root");
-  expect(formatted).toContain("level2:");
+  expect(formatted).toContain('root');
+  expect(formatted).toContain('level2:');
 });

package/tests/MultiQuoteParser.test.js

@@ -0,0 +1,463 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+
+const parser = new Parser();
+
+// Helper to extract the reference ID from a single-value link
+function getSingleRefId(result) {
+  // Single reference parses as: { id: null, values: [{ id: "the-id", values: [] }] }
+  if (
+    result.length === 1 &&
+    result[0].id === null &&
+    result[0].values.length === 1
+  ) {
+    return result[0].values[0].id;
+  }
+  return result[0]?.id;
+}
+
+// ============================================================================
+// Backtick Quote Tests (Single Backtick)
+// ============================================================================
+
+test('TestBacktickQuotedReference', () => {
+  const input = '`backtick quoted`';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('backtick quoted');
+});
+
+test('TestBacktickQuotedWithSpaces', () => {
+  const input = '`text with spaces`';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with spaces');
+});
+
+test('TestBacktickQuotedMultiline', () => {
+  const input = '(`line1\nline2`)';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(result[0].values[0].id).toBe('line1\nline2');
+});
+
+test('TestBacktickQuotedWithEscapedBacktick', () => {
+  const input = '`text with `` escaped backtick`';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with ` escaped backtick');
+});
+
+// ============================================================================
+// Single Quote Tests (with escaping)
+// ============================================================================
+
+test('TestSingleQuoteWithEscapedSingleQuote', () => {
+  const input = "'text with '' escaped quote'";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe("text with ' escaped quote");
+});
+
+// ============================================================================
+// Double Quote Tests (with escaping)
+// ============================================================================
+
+test('TestDoubleQuoteWithEscapedDoubleQuote', () => {
+  const input = '"text with "" escaped quote"';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with " escaped quote');
+});
+
+// ============================================================================
+// Double Quotes (2 quote chars) Tests
+// ============================================================================
+
+test('TestDoubleDoubleQuotes', () => {
+  const input = '""double double quotes""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('double double quotes');
+});
+
+test('TestDoubleDoubleQuotesWithSingleQuoteInside', () => {
+  const input = '""text with " inside""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with " inside');
+});
+
+test('TestDoubleDoubleQuotesWithEscape', () => {
+  const input = '""text with """" escaped double""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with "" escaped double');
+});
+
+test('TestDoubleSingleQuotes', () => {
+  const input = "''double single quotes''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('double single quotes');
+});
+
+test('TestDoubleSingleQuotesWithSingleQuoteInside', () => {
+  const input = "''text with ' inside''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe("text with ' inside");
+});
+
+test('TestDoubleSingleQuotesWithEscape', () => {
+  const input = "''text with '''' escaped single''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe("text with '' escaped single");
+});
+
+test('TestDoubleBacktickQuotes', () => {
+  const input = '``double backtick quotes``';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('double backtick quotes');
+});
+
+test('TestDoubleBacktickQuotesWithBacktickInside', () => {
+  const input = '``text with ` inside``';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with ` inside');
+});
+
+test('TestDoubleBacktickQuotesWithEscape', () => {
+  const input = '``text with ```` escaped backtick``';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with `` escaped backtick');
+});
+
+// ============================================================================
+// Triple Quotes (3 quote chars) Tests
+// ============================================================================
+
+test('TestTripleDoubleQuotes', () => {
+  const input = '"""triple double quotes"""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('triple double quotes');
+});
+
+test('TestTripleDoubleQuotesWithDoubleQuoteInside', () => {
+  const input = '"""text with "" inside"""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with "" inside');
+});
+
+test('TestTripleDoubleQuotesWithEscape', () => {
+  const input = '"""text with """""" escaped triple"""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with """ escaped triple');
+});
+
+test('TestTripleSingleQuotes', () => {
+  const input = "'''triple single quotes'''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('triple single quotes');
+});
+
+test('TestTripleSingleQuotesWithDoubleQuoteInside', () => {
+  const input = "'''text with '' inside'''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe("text with '' inside");
+});
+
+test('TestTripleSingleQuotesWithEscape', () => {
+  const input = "'''text with '''''' escaped triple'''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe("text with ''' escaped triple");
+});
+
+test('TestTripleBacktickQuotes', () => {
+  const input = '```triple backtick quotes```';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('triple backtick quotes');
+});
+
+test('TestTripleBacktickQuotesWithDoubleBacktickInside', () => {
+  const input = '```text with `` inside```';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with `` inside');
+});
+
+test('TestTripleBacktickQuotesWithEscape', () => {
+  const input = '```text with `````` escaped triple```';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with ``` escaped triple');
+});
+
+// ============================================================================
+// Quadruple Quotes (4 quote chars) Tests
+// ============================================================================
+
+test('TestQuadrupleDoubleQuotes', () => {
+  const input = '""""quadruple double quotes""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('quadruple double quotes');
+});
+
+test('TestQuadrupleDoubleQuotesWithTripleQuoteInside', () => {
+  const input = '""""text with """ inside""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with """ inside');
+});
+
+test('TestQuadrupleDoubleQuotesWithEscape', () => {
+  const input = '""""text with """""""" escaped quad""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with """" escaped quad');
+});
+
+test('TestQuadrupleSingleQuotes', () => {
+  const input = "''''quadruple single quotes''''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('quadruple single quotes');
+});
+
+test('TestQuadrupleBacktickQuotes', () => {
+  const input = '````quadruple backtick quotes````';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('quadruple backtick quotes');
+});
+
+// ============================================================================
+// Quintuple Quotes (5 quote chars) Tests
+// ============================================================================
+
+test('TestQuintupleDoubleQuotes', () => {
+  const input = '"""""quintuple double quotes"""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('quintuple double quotes');
+});
+
+test('TestQuintupleDoubleQuotesWithQuadQuoteInside', () => {
+  const input = '"""""text with """" inside"""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with """" inside');
+});
+
+test('TestQuintupleDoubleQuotesWithEscape', () => {
+  const input = '"""""text with """""""""" escaped quint"""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('text with """"" escaped quint');
+});
+
+test('TestQuintupleSingleQuotes', () => {
+  const input = "'''''quintuple single quotes'''''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('quintuple single quotes');
+});
+
+test('TestQuintupleBacktickQuotes', () => {
+  const input = '`````quintuple backtick quotes`````';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('quintuple backtick quotes');
+});
+
+// ============================================================================
+// Complex Scenarios Tests
+// ============================================================================
+
+test('TestMixedQuotesInLink', () => {
+  const input = '("double" \'single\' `backtick`)';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(result[0].values.length).toBe(3);
+  expect(result[0].values[0].id).toBe('double');
+  expect(result[0].values[1].id).toBe('single');
+  expect(result[0].values[2].id).toBe('backtick');
+});
+
+test('TestBacktickAsIdInLink', () => {
+  const input = '(`myId`: value1 value2)';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe('myId');
+  expect(result[0].values.length).toBe(2);
+});
+
+test('TestCodeBlockLikeContent', () => {
+  // This demonstrates using triple backticks for code-like content
+  const input = '```const x = 1;```';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('const x = 1;');
+});
+
+test('TestNestedQuotesInMarkdown', () => {
+  // Using double backticks to include single backtick
+  const input = '``Use `code` in markdown``';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('Use `code` in markdown');
+});
+
+test('TestSQLWithQuotes', () => {
+  // Using double single quotes to include single quote in SQL-like string
+  // Inside '', to get a single quote, we need '''' (4 single quotes = escaped pair)
+  const input = "''SELECT * FROM users WHERE name = ''''John''''''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe(
+    "SELECT * FROM users WHERE name = ''John''"
+  );
+});
+
+test('TestJSONStringWithQuotes', () => {
+  // Using double double quotes to include double quote in JSON-like string
+  const input = '""{"key": "value"}""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('{"key": "value"}');
+});
+
+// ============================================================================
+// Edge Cases
+// ============================================================================
+
+test('TestEmptySingleQuotedReference', () => {
+  const input = "''";
+  // Empty quoted reference should not match - becomes simple reference or fails
+  // Let's verify what happens
+  try {
+    const result = parser.parse(input);
+    // If it parses, check what we get
+    expect(result.length).toBeGreaterThanOrEqual(0);
+  } catch (e) {
+    // Expected for empty quotes
+    expect(e).toBeTruthy();
+  }
+});
+
+test('TestWhitespacePreservedInQuotes', () => {
+  const input = '"  spaces  "';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('  spaces  ');
+});
+
+test('TestMultilineInDoubleDoubleQuotes', () => {
+  const input = '(""line1\nline2"")';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(result[0].values[0].id).toBe('line1\nline2');
+});
+
+// ============================================================================
+// Unlimited Quotes (6+ quote chars) Tests
+// ============================================================================
+
+test('TestUnlimitedQuotes6', () => {
+  // Test 6-quote strings
+  const input = '""""""hello""""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('hello');
+});
+
+test('TestUnlimitedQuotes10', () => {
+  // Test 10-quote strings
+  const input = '""""""""""very deeply quoted""""""""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('very deeply quoted');
+});
+
+test('TestUnlimitedQuotes6WithInnerQuotes', () => {
+  // Test 6-quote strings with inner 5-quote sequences
+  const input = '""""""hello with """"" five quotes inside""""""';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('hello with """"" five quotes inside');
+});
+
+test('TestUnlimitedSingleQuotes7', () => {
+  // Test 7-quote single quote strings
+  const input = "'''''''seven single quotes'''''''";
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('seven single quotes');
+});
+
+test('TestUnlimitedBackticks8', () => {
+  // Test 8-quote backtick strings
+  const input = '````````eight backticks````````';
+  const result = parser.parse(input);
+
+  expect(result.length).toBe(1);
+  expect(getSingleRefId(result)).toBe('eight backticks');
+});