links-notation 0.11.2 → 0.12.0

package/tests/EdgeCaseParser.test.js

@@ -4,13 +4,13 @@ import { formatLinks } from '../src/Link.js';
 
 const parser = new Parser();
 
-test('EmptyLinkTest', () => {
+test('Empty link', () => {
   const source = ':';
   // Standalone ':' is now forbidden and should throw an error
   expect(() => parser.parse(source)).toThrow();
 });
 
-test('EmptyLinkWithParenthesesTest', () => {
+test('Empty link with parentheses', () => {
   const source = '()';
   const target = '()';
   const links = parser.parse(source);
@@ -18,13 +18,13 @@ test('EmptyLinkWithParenthesesTest', () => {
   expect(formattedLinks).toBe(target);
 });
 
-test('EmptyLinkWithEmptySelfReferenceTest', () => {
+test('Empty link with empty self reference', () => {
   const source = '(:)';
   // '(:)' is now forbidden and should throw an error
   expect(() => parser.parse(source)).toThrow();
 });
 
-test('TestAllFeaturesTest', () => {
+test('All features', () => {
   // Test single-line link with id
   let input = 'id: value1 value2';
   let result = parser.parse(input);
@@ -73,21 +73,21 @@ test('TestAllFeaturesTest', () => {
   expect(result.length).toBeGreaterThan(0);
 });
 
-test('TestEmptyDocumentTest', () => {
+test('Empty document', () => {
   const input = '';
   // Empty document should return empty array
   const result = parser.parse(input);
   expect(result).toEqual([]);
 });
 
-test('TestWhitespaceOnlyTest', () => {
+test('Whitespace only', () => {
   const input = '   \n   \n   ';
   // Whitespace-only document should return empty array
   const result = parser.parse(input);
   expect(result).toEqual([]);
 });
 
-test('TestEmptyLinksTest', () => {
+test('Empty links', () => {
   let input = '()';
   let result = parser.parse(input);
   expect(result.length).toBe(1);
@@ -105,7 +105,7 @@ test('TestEmptyLinksTest', () => {
   expect(result[0].values).toEqual([]);
 });
 
-test('TestSingletLinksTest', () => {
+test('Singlet links', () => {
   // Test singlet (1)
   let input = '(1)';
   let result = parser.parse(input);
@@ -155,7 +155,7 @@ test('TestSingletLinksTest', () => {
   expect(result[0].values[3].values).toEqual([]);
 });
 
-test('TestInvalidInputTest', () => {
+test('Invalid input', () => {
   const input = '(invalid';
   // Unclosed parentheses should throw an error
   expect(() => parser.parse(input)).toThrow();

package/tests/FormatConfig.test.js

@@ -0,0 +1,126 @@
+import { test, expect } from 'bun:test';
+import { Parser, Link, formatLinks, FormatConfig } from '../src/index.js';
+
+const parser = new Parser();
+
+test('Format config basic', () => {
+  const config = new FormatConfig();
+  expect(config.lessParentheses).toBe(false);
+  expect(config.maxLineLength).toBe(80);
+  expect(config.indentLongLines).toBe(false);
+});
+
+test('Format with line length limit', () => {
+  // Create a link with many references that exceeds line length
+  const link = new Link('sequence', [
+    new Link('1'), new Link('2'), new Link('3'), new Link('4'), new Link('5'),
+    new Link('6'), new Link('7'), new Link('8'), new Link('9'), new Link('10')
+  ]);
+
+  // Format with line length limit
+  // The line '(sequence: 1 2 3 4 5 6 7 8 9 10)' is 32 chars, so use threshold of 30
+  const config = new FormatConfig({
+    indentLongLines: true,
+    maxLineLength: 30,
+    preferInline: false
+  });
+
+  const output = link.format(config);
+  expect(output).toContain('sequence:');
+  expect(output).toContain('\n'); // Should be indented across multiple lines
+});
+
+test('Format with max inline refs', () => {
+  // Create a link with 4 references
+  const link = new Link('id', [new Link('1'), new Link('2'), new Link('3'), new Link('4')]);
+
+  // Format with maxInlineRefs=3 (should trigger indentation)
+  const config = new FormatConfig({
+    maxInlineRefs: 3,
+    preferInline: false
+  });
+
+  const output = link.format(config);
+  expect(output).toContain('id:');
+  expect(output).toContain('\n'); // Should be indented
+});
+
+test('Format with consecutive grouping', () => {
+  const links = [
+    new Link('SetA', [new Link('a')]),
+    new Link('SetA', [new Link('b')]),
+    new Link('SetA', [new Link('c')])
+  ];
+
+  const config = new FormatConfig({ groupConsecutive: true });
+
+  const output = formatLinks(links, config);
+
+  // Should group consecutive SetA links
+  // The output should have SetA with all values a, b, c
+  expect(output).toContain('SetA');
+  expect(output).toContain('a');
+  expect(output).toContain('b');
+  expect(output).toContain('c');
+});
+
+test('Format config less parentheses', () => {
+  const link = new Link('id', [new Link('value')]);
+
+  const config = new FormatConfig({ lessParentheses: true });
+
+  const output = link.format(config);
+  // Should not have outer parentheses
+  expect(output).toBe('id: value');
+});
+
+test('Format config custom indent', () => {
+  const link = new Link('id', [new Link('1'), new Link('2'), new Link('3'), new Link('4')]);
+
+  const config = new FormatConfig({
+    maxInlineRefs: 3,
+    preferInline: false,
+    indentString: '    ' // 4 spaces
+  });
+
+  const output = link.format(config);
+  // Check for custom indentation
+  expect(output).toContain('    '); // Should use 4 spaces
+});
+
+test('Roundtrip with line length formatting', () => {
+  // Create a simple link
+  const originalLink = new Link('test', [new Link('a'), new Link('b'), new Link('c')]);
+
+  // Format with indentation
+  const config = new FormatConfig({
+    maxInlineRefs: 2,
+    preferInline: false
+  });
+
+  const formatted = originalLink.format(config);
+
+  // Parse it back
+  const parsed = parser.parse(formatted);
+
+  // Should preserve the structure (though format may differ)
+  expect(parsed.length).toBeGreaterThan(0);
+});
+
+test('Should indent by length', () => {
+  const config = new FormatConfig({ indentLongLines: true, maxLineLength: 80 });
+
+  const shortLine = 'short';
+  const longLine = 'a'.repeat(100);
+
+  expect(config.shouldIndentByLength(shortLine)).toBe(false);
+  expect(config.shouldIndentByLength(longLine)).toBe(true);
+});
+
+test('Should indent by ref count', () => {
+  const config = new FormatConfig({ maxInlineRefs: 3 });
+
+  expect(config.shouldIndentByRefCount(2)).toBe(false);
+  expect(config.shouldIndentByRefCount(3)).toBe(false);
+  expect(config.shouldIndentByRefCount(4)).toBe(true);
+});

package/tests/IndentationConsistency.test.js

@@ -8,7 +8,7 @@ describe('Indentation Consistency Tests (Issue #135)', () => {
     parser = new Parser();
   });
 
-  test('leading spaces vs no leading spaces should produce same result', () => {
+  test('Leading spaces vs no leading spaces', () => {
     // Example with 2 leading spaces (from issue #135)
     const withLeading = `  TELEGRAM_BOT_TOKEN: '849...355:AAG...rgk_YZk...aPU'
   TELEGRAM_ALLOWED_CHATS:

package/tests/IndentedIdSyntax.test.js

@@ -4,7 +4,7 @@ import { formatLinks } from "../src/Link.js";
 
 const parser = new Parser();
 
-test("Basic indented ID syntax - issue #21", () => {
+test("Basic indented ID syntax", () => {
   const indentedSyntax = `3:
   papa
   loves
@@ -145,7 +145,7 @@ test("Empty indented ID should work", () => {
   expect(formatted).toBe("(empty)");
 });
 
-test("Equivalence test - comprehensive", () => {
+test("Equivalence test comprehensive", () => {
   const testCases = [
     {
       indented: "test:\n  one",

package/tests/Link.test.js

@@ -30,7 +30,7 @@ test('Link toString with id and values', () => {
   expect(link.toString()).toBe('(parent: child1 child2)');
 });
 
-test('Link escapeReference for simple reference', () => {
+test('Link escapeReference simple', () => {
   expect(Link.escapeReference('simple')).toBe('simple');
 });
 

package/tests/LinksGroup.test.js

@@ -32,9 +32,36 @@ test('LinksGroup toString', () => {
   const element = new Link('root');
   const children = [new Link('child1'), new Link('child2')];
   const group = new LinksGroup(element, children);
-  
+
   const str = group.toString();
   expect(str).toContain('(root)');
   expect(str).toContain('(child1)');
   expect(str).toContain('(child2)');
+});
+
+test('LinksGroup constructor equivalent test', () => {
+  // Test creating a LinksGroup structure in an equivalent way
+  const root = new Link('root');
+  const children = [new Link('child1'), new Link('child2')];
+
+  // Create a group with an id
+  const group = new LinksGroup(new Link('group'), [new LinksGroup(root), ...children.map(c => new LinksGroup(c))]);
+
+  expect(group.element.id).toBe('group');
+  expect(group.children.length).toBe(3);
+  expect(group.children[0].element).toBe(root);
+});
+
+test('LinksGroup append to links list test', () => {
+  const element = new Link('root');
+  const children = [new Link('child1'), new Link('child2')];
+  const group = new LinksGroup(element, children);
+
+  const list = [];
+  group._appendToList(list);
+
+  expect(list.length).toBe(3);
+  expect(list[0]).toBe(element);
+  expect(list[1]).toBe(children[0]);
+  expect(list[2]).toBe(children[1]);
 });

package/tests/MixedIndentationModes.test.js

@@ -4,7 +4,7 @@ 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:
     (
@@ -31,7 +31,7 @@ test("Hero example - mixed modes - issue #105", () => {
   expect(formatted).toContain("Wesley Crusher");
 });
 
-test("Hero example - alternative format - issue #105", () => {
+test("Hero example alternative format", () => {
   const input = `empInfo
   (
     employees:
@@ -60,7 +60,7 @@ test("Hero example - alternative format - issue #105", () => {
   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`;
 
@@ -114,7 +114,7 @@ test("Set/object context without colon", () => {
   expect(formatted).toContain("employees");
 });
 
-test("Sequence/list context with colon", () => {
+test("Sequence context with colon", () => {
   const input = `employees:
   James Kirk
   Jean-Luc Picard

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)

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