links-notation 0.11.2 → 0.13.0

package/tests/ApiTests.test.js

@@ -1,9 +1,25 @@
 import { test, expect } from 'bun:test';
 import { Parser } from '../src/Parser.js';
-import { Link } from '../src/Link.js';
+import { Link, formatLinks } from '../src/Link.js';
+import { FormatOptions } from '../src/FormatOptions.js';
 
 const parser = new Parser();
 
+test('test_is_ref', () => {
+  // JS doesn't have separate Ref/Link types, but we can test simple link behavior
+  const simpleLink = new Link('some_value');
+  expect(simpleLink.id).toBe('some_value');
+  expect(simpleLink.values).toEqual([]);
+});
+
+test('test_is_link', () => {
+  // Test link with values
+  const link = new Link('id', [new Link('child')]);
+  expect(link.id).toBe('id');
+  expect(link.values.length).toBe(1);
+  expect(link.values[0].id).toBe('child');
+});
+
 test('test_is_ref equivalent', () => {
   // JS doesn't have separate Ref/Link types, but we can test simple link behavior
   const simpleLink = new Link('some_value');
@@ -28,7 +44,7 @@ test('test_empty_link', () => {
 test('test_simple_link', () => {
   const input = '(1: 1 1)';
   const parsed = parser.parse(input);
-  
+
   // Validate regular formatting
   const output = parsed[0].format();
   const expected = '(1: 1 1)'; // JS format matches input
@@ -38,7 +54,7 @@ test('test_simple_link', () => {
 test('test_link_with_source_target', () => {
   const input = '(index: source target)';
   const parsed = parser.parse(input);
-  
+
   // Validate regular formatting
   const output = parsed[0].format();
   expect(output).toBe(input);
@@ -47,7 +63,7 @@ test('test_link_with_source_target', () => {
 test('test_link_with_source_type_target', () => {
   const input = '(index: source type target)';
   const parsed = parser.parse(input);
-  
+
   // Validate regular formatting
   const output = parsed[0].format();
   expect(output).toBe(input);
@@ -56,7 +72,7 @@ test('test_link_with_source_type_target', () => {
 test('test_single_line_format', () => {
   const input = 'id: value1 value2';
   const parsed = parser.parse(input);
-  
+
   // The parser should handle single-line format
   const output = parsed[0].format(true); // lessParentheses mode
   expect(output).toContain('id');
@@ -67,8 +83,89 @@ test('test_single_line_format', () => {
 test('test_quoted_references', () => {
   const input = '("quoted id": "value with spaces")';
   const parsed = parser.parse(input);
-  
+
   const output = parsed[0].format();
   expect(output).toContain('quoted id');
   expect(output).toContain('value with spaces');
-});
+});
+
+test('test_quoted_references_parsing', () => {
+  // Test that quoted references are parsed correctly
+  const input = '("quoted id": "value with spaces")';
+  const parsed = parser.parse(input);
+
+  // Verify parsing worked correctly
+  const output = formatLinks(parsed);
+  expect(output).toContain('quoted id');
+  expect(output).toContain('value with spaces');
+});
+
+test('test_indented_id_syntax_parsing', () => {
+  // Test that indented ID syntax is parsed correctly
+  const indented = `id:
+  value1
+  value2`;
+  const inline = '(id: value1 value2)';
+
+  const indentedParsed = parser.parse(indented);
+  const inlineParsed = parser.parse(inline);
+
+  // Both should produce equivalent structures
+  const indentedOutput = formatLinks(indentedParsed);
+  const inlineOutput = formatLinks(inlineParsed);
+  expect(indentedOutput).toBe(inlineOutput);
+  expect(indentedOutput).toBe('(id: value1 value2)');
+});
+
+test('test_indented_id_syntax_roundtrip', () => {
+  const input = `id:
+  value1
+  value2`;
+  const parsed = parser.parse(input);
+
+  // Validate that we can format with indented syntax using FormatOptions
+  const options = new FormatOptions();
+  options.maxInlineRefs = 1; // Force indentation with more than 1 ref
+  options.preferInline = false;
+  const output = formatLinks(parsed, options);
+  expect(output).toBe(input);
+});
+
+test('test_multiple_indented_id_syntax_parsing', () => {
+  // Test that multiple indented ID links are parsed correctly
+  const indented = `id1:
+  a
+  b
+id2:
+  c
+  d`;
+  const inline = `(id1: a b)
+(id2: c d)`;
+
+  const indentedParsed = parser.parse(indented);
+  const inlineParsed = parser.parse(inline);
+
+  // Both should produce equivalent structures
+  const indentedOutput = formatLinks(indentedParsed);
+  const inlineOutput = formatLinks(inlineParsed);
+  expect(indentedOutput).toBe(inlineOutput);
+  expect(indentedOutput).toBe(`(id1: a b)
+(id2: c d)`);
+});
+
+test('test_multiple_indented_id_syntax_roundtrip', () => {
+  const input = `id1:
+  a
+  b
+id2:
+  c
+  d`;
+  const parsed = parser.parse(input);
+
+  // Validate that we can format with indented syntax using FormatOptions
+  const options = new FormatOptions();
+  options.maxInlineRefs = 1; // Force indentation with more than 1 ref
+  options.preferInline = false;
+  const output = formatLinks(parsed, options);
+  expect(output).toBe(input);
+});

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,31 +73,31 @@ 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);
   expect(result[0].id).toBe(null);
   expect(result[0].values).toEqual([]);
-  
+
   // '(:)' is now forbidden
   input = '(:)';
   expect(() => parser.parse(input)).toThrow();
-  
+
   input = '(id:)';
   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,8 +155,8 @@ 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,148 @@
+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

@@ -1,16 +1,16 @@
-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("Basic indented ID syntax - issue #21", () => {
+test('Basic indented ID syntax', () => {
   const indentedSyntax = `3:
   papa
   loves
   mama`;
 
-  const inlineSyntax = "(3: papa loves mama)";
+  const inlineSyntax = '(3: papa loves mama)';
 
   const indentedResult = parser.parse(indentedSyntax);
   const inlineResult = parser.parse(inlineSyntax);
@@ -19,25 +19,25 @@ test("Basic indented ID syntax - issue #21", () => {
   expect(indentedResult).toEqual(inlineResult);
 
   // Both should format to the same inline syntax
-  expect(formatLinks(indentedResult)).toBe("(3: papa loves mama)");
-  expect(formatLinks(inlineResult)).toBe("(3: papa loves mama)");
+  expect(formatLinks(indentedResult)).toBe('(3: papa loves mama)');
+  expect(formatLinks(inlineResult)).toBe('(3: papa loves mama)');
 });
 
-test("Indented ID syntax with single value", () => {
+test('Indented ID syntax with single value', () => {
   const input = `greeting:
   hello`;
 
   const result = parser.parse(input);
   const formatted = formatLinks(result);
 
-  expect(formatted).toBe("(greeting: hello)");
+  expect(formatted).toBe('(greeting: hello)');
   expect(result.length).toBe(1);
-  expect(result[0].id).toBe("greeting");
+  expect(result[0].id).toBe('greeting');
   expect(result[0].values.length).toBe(1);
-  expect(result[0].values[0].id).toBe("hello");
+  expect(result[0].values[0].id).toBe('hello');
 });
 
-test("Indented ID syntax with multiple values", () => {
+test('Indented ID syntax with multiple values', () => {
   const input = `action:
   run
   fast
@@ -46,13 +46,13 @@ test("Indented ID syntax with multiple values", () => {
   const result = parser.parse(input);
   const formatted = formatLinks(result);
 
-  expect(formatted).toBe("(action: run fast now)");
+  expect(formatted).toBe('(action: run fast now)');
   expect(result.length).toBe(1);
-  expect(result[0].id).toBe("action");
+  expect(result[0].id).toBe('action');
   expect(result[0].values.length).toBe(3);
 });
 
-test("Indented ID syntax with numeric ID", () => {
+test('Indented ID syntax with numeric ID', () => {
   const input = `42:
   answer
   to
@@ -61,10 +61,10 @@ test("Indented ID syntax with numeric ID", () => {
   const result = parser.parse(input);
   const formatted = formatLinks(result);
 
-  expect(formatted).toBe("(42: answer to everything)");
+  expect(formatted).toBe('(42: answer to everything)');
 });
 
-test("Indented ID syntax with quoted ID", () => {
+test('Indented ID syntax with quoted ID', () => {
   const input = `"complex id":
   value1
   value2`;
@@ -75,7 +75,7 @@ test("Indented ID syntax with quoted ID", () => {
   expect(formatted).toBe("('complex id': value1 value2)");
 });
 
-test("Multiple indented ID links", () => {
+test('Multiple indented ID links', () => {
   const input = `first:
   a
   b
@@ -87,10 +87,10 @@ second:
   const formatted = formatLinks(result);
 
   expect(result.length).toBe(2);
-  expect(formatted).toBe("(first: a b)\n(second: c d)");
+  expect(formatted).toBe('(first: a b)\n(second: c d)');
 });
 
-test("Mixed indented and regular syntax", () => {
+test('Mixed indented and regular syntax', () => {
   const input = `first:
   a
   b
@@ -101,12 +101,12 @@ third value`;
   expect(result.length).toBe(3);
 
   const formatted = formatLinks(result);
-  expect(formatted).toContain("(first: a b)");
-  expect(formatted).toContain("(second: c d)");
-  expect(formatted).toContain("third value");
+  expect(formatted).toContain('(first: a b)');
+  expect(formatted).toContain('(second: c d)');
+  expect(formatted).toContain('third value');
 });
 
-test("Unsupported colon-only syntax should fail", () => {
+test('Unsupported colon-only syntax should fail', () => {
   const input = `:
   papa
   loves
@@ -117,7 +117,7 @@ test("Unsupported colon-only syntax should fail", () => {
   }).toThrow();
 });
 
-test("Indented ID with deeper nesting", () => {
+test('Indented ID with deeper nesting', () => {
   const input = `root:
   child1
   child2
@@ -129,36 +129,36 @@ test("Indented ID with deeper nesting", () => {
 
   // The root should have child1 and child2 as values
   const rootLink = result[0];
-  expect(rootLink.id).toBe("root");
+  expect(rootLink.id).toBe('root');
   expect(rootLink.values.length).toBe(2);
 });
 
-test("Empty indented ID should work", () => {
-  const input = "empty:";
+test('Empty indented ID should work', () => {
+  const input = 'empty:';
 
   const result = parser.parse(input);
   expect(result.length).toBe(1);
-  expect(result[0].id).toBe("empty");
+  expect(result[0].id).toBe('empty');
   expect(result[0].values.length).toBe(0);
 
   const formatted = formatLinks(result);
-  expect(formatted).toBe("(empty)");
+  expect(formatted).toBe('(empty)');
 });
 
-test("Equivalence test - comprehensive", () => {
+test('Equivalence test comprehensive', () => {
   const testCases = [
     {
-      indented: "test:\n  one",
-      inline: "(test: one)"
+      indented: 'test:\n  one',
+      inline: '(test: one)',
     },
     {
-      indented: "x:\n  a\n  b\n  c",
-      inline: "(x: a b c)"
+      indented: 'x:\n  a\n  b\n  c',
+      inline: '(x: a b c)',
     },
     {
-      indented: "\"quoted\":\n  value",
-      inline: "(\"quoted\": value)"
-    }
+      indented: '"quoted":\n  value',
+      inline: '("quoted": value)',
+    },
   ];
 
   for (const testCase of testCases) {
@@ -168,4 +168,4 @@ test("Equivalence test - comprehensive", () => {
     expect(indentedResult).toEqual(inlineResult);
     expect(formatLinks(indentedResult)).toBe(formatLinks(inlineResult));
   }
-});
+});

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');
 });
 
@@ -63,7 +63,7 @@ test('Link equals', () => {
   const link1 = new Link('test', [new Link('child')]);
   const link2 = new Link('test', [new Link('child')]);
   const link3 = new Link('different', [new Link('child')]);
-  
+
   expect(link1.equals(link2)).toBe(true);
   expect(link1.equals(link3)).toBe(false);
-});
+});

package/tests/LinksGroup.test.js

@@ -6,7 +6,7 @@ test('LinksGroup constructor', () => {
   const element = new Link('root');
   const children = [new Link('child1'), new Link('child2')];
   const group = new LinksGroup(element, children);
-  
+
   expect(group.element).toBe(element);
   expect(group.children).toBe(children);
 });
@@ -16,10 +16,10 @@ test('LinksGroup toList flattens structure', () => {
   const child1 = new Link('child1');
   const child2 = new Link('child2');
   const grandchild = new Link('grandchild');
-  
+
   const childGroup = new LinksGroup(child2, [grandchild]);
   const group = new LinksGroup(root, [child1, childGroup]);
-  
+
   const list = group.toList();
   expect(list.length).toBe(4);
   expect(list[0]).toBe(root);
@@ -32,9 +32,39 @@ 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]);
+});