links-notation 0.11.0 → 0.12.0

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);
@@ -148,7 +148,7 @@ test('Test nested links', () => {
   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);
@@ -157,10 +157,37 @@ test('Test indentation (parser)', () => {
   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,102 @@
+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);
@@ -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');
 });