links-notation 0.11.2 → 0.13.0

package/tests/MultilineParser.test.js

@@ -4,7 +4,7 @@ import { formatLinks } from '../src/Link.js';
 
 const parser = new Parser();
 
-test('TwoLinksTest', () => {
+test('Two links', () => {
   const source = `(first: x y)
 (second: a b)`;
   const links = parser.parse(source);
@@ -12,7 +12,7 @@ test('TwoLinksTest', () => {
   expect(target).toBe(source);
 });
 
-test('ParseAndStringifyTest', () => {
+test('Parse and stringify', () => {
   const source = `(papa (lovesMama: loves mama))
 (son lovesMama)
 (daughter lovesMama)
@@ -22,7 +22,7 @@ test('ParseAndStringifyTest', () => {
   expect(target).toBe(source);
 });
 
-test('ParseAndStringifyTest2', () => {
+test('Parse and stringify test 2', () => {
   const source = `father (lovesMom: loves mom)
 son lovesMom
 daughter lovesMom
@@ -32,7 +32,7 @@ all (love mom)`;
   expect(target).toBe(source);
 });
 
-test('ParseAndStringifyWithLessParenthesesTest', () => {
+test('Parse and stringify with less parentheses', () => {
   const source = `lovesMama: loves mama
 papa lovesMama
 son lovesMama
@@ -43,7 +43,7 @@ all (love mama)`;
   expect(target).toBe(source);
 });
 
-test('DuplicateIdentifiersTest', () => {
+test('Duplicate identifiers', () => {
   const source = `(a: a b)
 (a: b c)`;
   const target = `(a: a b)
@@ -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

@@ -105,7 +105,7 @@ test('Parse nested structure with indentation', () => {
   expect(result[2].values.length).toBe(2);
 });
 
-test('Test indentation consistency', () => {
+test('Indentation consistency', () => {
   // Test that indentation must be consistent
   const input = `parent
   child1
@@ -135,7 +135,7 @@ test('Complex indentation', () => {
   expect(result.length).toBe(6);
 });
 
-test('Test nested links', () => {
+test('Nested links', () => {
   const input = '(1: (2: (3: 3)))';
   const parsed = parser.parse(input);
   expect(parsed.length).toBeGreaterThan(0);
@@ -143,24 +143,53 @@ test('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);
 });
 
-test('Test indentation (parser)', () => {
+test('Indentation parser', () => {
   const input = 'parent\n  child1\n  child2';
   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);
 });
 
-test('Test nested indentation (parser)', () => {
+test('Nested indentation parser', () => {
   const input = 'parent\n  child\n    grandchild';
   const result = parser.parse(input);
   expect(result.length).toBeGreaterThan(0);
   // Should create nested structure with proper hierarchy
   expect(result.length).toBeGreaterThanOrEqual(1);
-});
+});
+
+test('Three level nesting roundtrip', () => {
+  const input = '(1: (2: (3: 3)))';
+  const parsed = parser.parse(input);
+
+  // Validate round-trip
+  const output = formatLinks(parsed);
+  expect(output).toBe(input);
+});
+
+test('Deep nested structure roundtrip', () => {
+  const input = '(a: (b: (c: (d: d))))';
+  const parsed = parser.parse(input);
+
+  // Validate round-trip
+  const output = formatLinks(parsed);
+  expect(output).toBe(input);
+});
+
+test('Multiple nested links roundtrip', () => {
+  const input = '(parent: (child1: value1) (child2: value2))';
+  const parsed = parser.parse(input);
+
+  // Validate round-trip
+  const output = formatLinks(parsed);
+  expect(output).toBe(input);
+});

package/tests/NestedSelfReference.test.js

@@ -0,0 +1,104 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+
+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 parser = new Parser();
+  const links = parser.parse(notation);
+
+  // Should parse exactly one top-level link
+  expect(links.length).toBe(1);
+
+  const link = links[0];
+
+  // Top-level link should have ID "obj_0"
+  expect(link.id).toBe('obj_0');
+
+  // Should have: type marker + 2 pairs = 3 values
+  expect(link.values.length).toBe(3);
+
+  // First value is the type marker "dict"
+  expect(link.values[0].id).toBe('dict');
+
+  // Second and third values are the two pairs
+  const pair1 = link.values[1];
+  const pair2 = link.values[2];
+
+  // Pair 1: ((str bmFtZQ==) (str ZGljdDE=))
+  // This is a parenthesized expression containing two sub-expressions
+  expect(pair1.id).toBe(null);
+  expect(pair1.values.length).toBe(2);
+
+  // First element of pair1: (str bmFtZQ==)
+  expect(pair1.values[0].id).toBe(null);
+  expect(pair1.values[0].values.length).toBe(2); // "str" and "bmFtZQ=="
+  expect(pair1.values[0].values[0].id).toBe('str');
+  expect(pair1.values[0].values[1].id).toBe('bmFtZQ==');
+
+  // Second element of pair1: (str ZGljdDE=)
+  expect(pair1.values[1].id).toBe(null);
+  expect(pair1.values[1].values.length).toBe(2); // "str" and "ZGljdDE="
+  expect(pair1.values[1].values[0].id).toBe('str');
+  expect(pair1.values[1].values[1].id).toBe('ZGljdDE=');
+
+  // Pair 2: ((str b3RoZXI=) (obj_1: dict ...))
+  // This is the critical test - the second element should be a self-referenced dict
+  expect(pair2.id).toBe(null);
+  expect(pair2.values.length).toBe(2);
+
+  // First element of pair2: (str b3RoZXI=)
+  expect(pair2.values[0].id).toBe(null);
+  expect(pair2.values[0].values.length).toBe(2);
+  expect(pair2.values[0].values[0].id).toBe('str');
+  expect(pair2.values[0].values[1].id).toBe('b3RoZXI=');
+
+  // Second element of pair2: (obj_1: dict ((str bmFtZQ==) (str ZGljdDI=)) ((str b3RoZXI=) obj_0))
+  // THIS IS THE KEY TEST - obj_1 should have its ID preserved
+  const obj1 = pair2.values[1];
+  expect(obj1.id).toBe('obj_1'); // This is the self-reference ID
+  expect(obj1.values).toBeTruthy(); // Should have nested values (dict definition)
+  expect(obj1.values.length).toBe(3); // type marker + 2 pairs
+
+  // obj_1's type marker
+  expect(obj1.values[0].id).toBe('dict');
+
+  // obj_1's first pair: ((str bmFtZQ==) (str ZGljdDI=))
+  const obj1_pair1 = obj1.values[1];
+  expect(obj1_pair1.values.length).toBe(2);
+  expect(obj1_pair1.values[0].values[0].id).toBe('str');
+  expect(obj1_pair1.values[0].values[1].id).toBe('bmFtZQ==');
+  expect(obj1_pair1.values[1].values[0].id).toBe('str');
+  expect(obj1_pair1.values[1].values[1].id).toBe('ZGljdDI=');
+
+  // obj_1's second pair: ((str b3RoZXI=) obj_0) - reference back to obj_0
+  const obj1_pair2 = obj1.values[2];
+  expect(obj1_pair2.values.length).toBe(2);
+  expect(obj1_pair2.values[0].values[0].id).toBe('str');
+  expect(obj1_pair2.values[0].values[1].id).toBe('b3RoZXI=');
+  expect(obj1_pair2.values[1].id).toBe('obj_0'); // Reference to obj_0
+  expect(obj1_pair2.values[1].values).toEqual([]); // Just a reference, no nested values
+});
+
+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 parser = new Parser();
+  const links = parser.parse(notation);
+
+  expect(links.length).toBe(1);
+  expect(links[0].id).toBe('obj_0');
+  expect(links[0].values.length).toBe(4); // list + 1 + 2 + obj_1
+
+  // The fourth value should be obj_1 with a self-reference
+  const obj1 = links[0].values[3];
+  expect(obj1.id).toBe('obj_1');
+  expect(obj1.values.length).toBe(4); // list + 3 + 4 + obj_0
+  expect(obj1.values[3].id).toBe('obj_0'); // Reference back to obj_0
+});

package/tests/SingleLineParser.test.js

@@ -4,28 +4,28 @@ import { formatLinks } from '../src/Link.js';
 
 const parser = new Parser();
 
-test('SingleLinkTest', () => {
+test('Single link', () => {
   const source = '(address: source target)';
   const links = parser.parse(source);
   const target = formatLinks(links);
   expect(target).toBe(source);
 });
 
-test('TripletSingleLinkTest', () => {
+test('Triplet single link', () => {
   const source = '(papa has car)';
   const links = parser.parse(source);
   const target = formatLinks(links);
   expect(target).toBe(source);
 });
 
-test('BugTest1', () => {
+test('Bug test 1', () => {
   const source = '(ignore conan-center-index repository)';
   const links = parser.parse(source);
   const target = formatLinks(links);
   expect(target).toBe(source);
 });
 
-test('QuotedReferencesTest', () => {
+test('Quoted references', () => {
   const source = `(a: 'b' "c")`;
   const target = `(a: b c)`;
   const links = parser.parse(source);
@@ -33,7 +33,7 @@ test('QuotedReferencesTest', () => {
   expect(formattedLinks).toBe(target);
 });
 
-test('QuotedReferencesWithSpacesTest', () => {
+test('Quoted references with spaces', () => {
   const source = `('a a': 'b b' "c c")`;
   const target = `('a a': 'b b' 'c c')`;
   const links = parser.parse(source);
@@ -127,7 +127,7 @@ test('Test value link', () => {
   expect(result.length).toBeGreaterThan(0);
 });
 
-test('ParseQuotedReferencesValuesOnly', () => {
+test('Parse quoted references values only', () => {
   const source = `"has space" 'has:colon'`;
   const parser = new Parser();
   const links = parser.parse(source);
@@ -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);
@@ -226,4 +226,84 @@ test('Test value link (parser)', () => {
   expect(result.length).toBe(1);
   expect(result[0].id).toBe(null);
   expect(result[0].values.length).toBe(3);
-});
+});
+
+test('Multiline without id', () => {
+  // Test that '(:)' syntax is forbidden and should throw an error
+  const input = '(: value1 value2)';
+  // JS parser forbids this syntax
+  expect(() => parser.parse(input)).toThrow();
+});
+
+test('Parse values only standalone colon', () => {
+  // Test that standalone ':' is forbidden and should throw an error
+  const input = ': value1 value2';
+  // JS parser forbids this syntax
+  expect(() => parser.parse(input)).toThrow();
+});
+
+test('Quoted references with spaces in link', () => {
+  const input = '(id: "value with spaces")';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe('id');
+  expect(result[0].values.length).toBe(1);
+  expect(result[0].values[0].id).toBe('value with spaces');
+});
+
+test('Single line without id', () => {
+  // Test parsing a single line without ID (just values)
+  const input = '(value1 value2)';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe(null);
+  expect(result[0].values.length).toBe(2);
+});
+
+test('Link with id', () => {
+  const input = '(id: a b c)';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe('id');
+  expect(result[0].values.length).toBe(3);
+});
+
+test('Quoted reference', () => {
+  const input = '"quoted value"';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe(null);
+  expect(result[0].values.length).toBe(1);
+  expect(result[0].values[0].id).toBe('quoted value');
+});
+
+test('Quoted references with special chars', () => {
+  const input = '("special:char" "another@char")';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe(null);
+  expect(result[0].values.length).toBe(2);
+  expect(result[0].values[0].id).toBe('special:char');
+  expect(result[0].values[1].id).toBe('another@char');
+});
+
+test('Simple reference', () => {
+  const input = 'simplereference';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Single line link', () => {
+  const input = 'id: value1 value2';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe('id');
+  expect(result[0].values.length).toBe(2);
+});
+
+test('Single line with id', () => {
+  const input = 'myid: val1 val2';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+  expect(result[0].id).toBe('myid');
+});