links-notation 0.12.0 → 0.13.0

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');
+});

package/tests/MultilineParser.test.js

@@ -61,7 +61,7 @@ test('Test complex structure', () => {
   Value
     (property: name type)
     (method: name params return)`;
-  
+
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
 });
@@ -75,44 +75,44 @@ simple_ref
   nested1
   nested2
 )`;
-  
+
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
 });
 
 test('Test multiline with id', () => {
   // Test multi-line link with id
-  const input = "(id: value1 value2)";
+  const input = '(id: value1 value2)';
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
 });
 
 test('Test multiple top level elements', () => {
   // Test multiple top-level elements
-  const input = "(elem1: val1)\n(elem2: val2)";
+  const input = '(elem1: val1)\n(elem2: val2)';
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
 });
 
 test('Test multiline simple links', () => {
-  const input = "(1: 1 1)\n(2: 2 2)";
+  const input = '(1: 1 1)\n(2: 2 2)';
   const parsed = parser.parse(input);
   expect(parsed.length).toBeGreaterThan(0);
-  
+
   // Validate regular formatting
   const output = formatLinks(parsed);
-  expect(output).toContain("(1: 1 1)");
-  expect(output).toContain("(2: 2 2)");
-  
+  expect(output).toContain('(1: 1 1)');
+  expect(output).toContain('(2: 2 2)');
+
   // Validate alternate formatting matches input
   const outputAlternate = formatLinks(parsed);
   expect(outputAlternate).toBe(input);
 });
 
 test('Test indented children', () => {
-  const input = "parent\n  child1\n  child2";
+  const input = 'parent\n  child1\n  child2';
   const parsed = parser.parse(input);
-  
+
   // The parsed structure should have parent with children
   expect(parsed.length).toBeGreaterThan(0);
-});
+});

package/tests/MultilineQuotedString.test.js

@@ -1,9 +1,9 @@
-import { test, expect } from "bun:test";
-import { Parser } from "../src/Parser.js";
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
 
 const parser = new Parser();
 
-test("TestMultilineDoubleQuotedReference", () => {
+test('TestMultilineDoubleQuotedReference', () => {
   const input = `(
   "long
 string literal representing
@@ -32,7 +32,7 @@ long string literal
 as another reference`);
 });
 
-test("TestSimpleMultilineDoubleQuoted", () => {
+test('TestSimpleMultilineDoubleQuoted', () => {
   const input = `("line1
 line2")`;
   const result = parser.parse(input);
@@ -44,10 +44,10 @@ line2")`;
   expect(link.id).toBe(null);
   expect(link.values).toBeTruthy();
   expect(link.values.length).toBe(1);
-  expect(link.values[0].id).toBe("line1\nline2");
+  expect(link.values[0].id).toBe('line1\nline2');
 });
 
-test("TestSimpleMultilineSingleQuoted", () => {
+test('TestSimpleMultilineSingleQuoted', () => {
   const input = `('line1
 line2')`;
   const result = parser.parse(input);
@@ -59,10 +59,10 @@ line2')`;
   expect(link.id).toBe(null);
   expect(link.values).toBeTruthy();
   expect(link.values.length).toBe(1);
-  expect(link.values[0].id).toBe("line1\nline2");
+  expect(link.values[0].id).toBe('line1\nline2');
 });
 
-test("TestMultilineQuotedAsId", () => {
+test('TestMultilineQuotedAsId', () => {
   const input = `("multi
 line
 id": value1 value2)`;
@@ -72,7 +72,7 @@ id": value1 value2)`;
   expect(result.length).toBe(1);
 
   const link = result[0];
-  expect(link.id).toBe("multi\nline\nid");
+  expect(link.id).toBe('multi\nline\nid');
   expect(link.values).toBeTruthy();
   expect(link.values.length).toBe(2);
 });

package/tests/NestedParser.test.js

@@ -143,7 +143,7 @@ test('Nested links', () => {
   // Validate regular formatting
   const output = formatLinks(parsed);
   expect(output).toBeTruthy();
-  
+
   // Validate that the structure is properly nested
   expect(parsed.length).toBe(1);
 });
@@ -153,7 +153,9 @@ test('Indentation parser', () => {
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
   // Should have parent link
-  const hasParentLink = result.some(l => l.values && l.values.some(v => v.id === 'parent'));
+  const hasParentLink = result.some(
+    (l) => l.values && l.values.some((v) => v.id === 'parent')
+  );
   expect(hasParentLink).toBe(true);
 });
 
@@ -190,4 +192,4 @@ test('Multiple nested links roundtrip', () => {
   // Validate round-trip
   const output = formatLinks(parsed);
   expect(output).toBe(input);
-});
+});

package/tests/NestedSelfReference.test.js

@@ -5,7 +5,8 @@ test('Nested self-referenced object in pair value', () => {
   // Test case from PARSER_BUG.md
   // This should parse a dict with two pairs, where the second pair's value
   // is itself a self-referenced dict definition (obj_1: dict ...)
-  const notation = '(obj_0: dict ((str bmFtZQ==) (str ZGljdDE=)) ((str b3RoZXI=) (obj_1: dict ((str bmFtZQ==) (str ZGljdDI=)) ((str b3RoZXI=) obj_0))))';
+  const notation =
+    '(obj_0: dict ((str bmFtZQ==) (str ZGljdDE=)) ((str b3RoZXI=) (obj_1: dict ((str bmFtZQ==) (str ZGljdDI=)) ((str b3RoZXI=) obj_0))))';
 
   const parser = new Parser();
   const links = parser.parse(notation);
@@ -85,7 +86,8 @@ test('Nested self-referenced object in pair value', () => {
 
 test('Self-reference as direct child works correctly', () => {
   // This pattern should work (and did work before)
-  const notation = '(obj_0: list (int 1) (int 2) (obj_1: list (int 3) (int 4) obj_0))';
+  const notation =
+    '(obj_0: list (int 1) (int 2) (obj_1: list (int 3) (int 4) obj_0))';
 
   const parser = new Parser();
   const links = parser.parse(notation);

package/tests/SingleLineParser.test.js

@@ -161,7 +161,7 @@ test('Test special characters in quotes', () => {
   let input = '("key:with:colons": "value(with)parens")';
   let result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
-  
+
   input = "('key with spaces': 'value: with special chars')";
   result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
@@ -306,4 +306,4 @@ test('Single line with id', () => {
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
   expect(result[0].id).toBe('myid');
-});
+});