links-notation 0.11.0 → 0.12.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,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

@@ -0,0 +1,128 @@
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+describe('Indentation Consistency Tests (Issue #135)', () => {
+  let parser;
+
+  beforeEach(() => {
+    parser = new Parser();
+  });
+
+  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:
+    -1002975819706
+    -1002861722681
+  TELEGRAM_HIVE_OVERRIDES:
+    --all-issues
+    --once
+  TELEGRAM_BOT_VERBOSE: true`;
+
+    // Example without leading spaces (from issue #135)
+    const withoutLeading = `TELEGRAM_BOT_TOKEN: '849...355:AAG...rgk_YZk...aPU'
+TELEGRAM_ALLOWED_CHATS:
+  -1002975819706
+  -1002861722681
+TELEGRAM_HIVE_OVERRIDES:
+  --all-issues
+  --once
+TELEGRAM_BOT_VERBOSE: true`;
+
+    const resultWith = parser.parse(withLeading);
+    const resultWithout = parser.parse(withoutLeading);
+
+    // Compare the entire formatted output (complete round trip test)
+    expect(formatLinks(resultWith)).toBe(formatLinks(resultWithout));
+  });
+
+  test('two spaces vs four spaces indentation', () => {
+    // Example with 2 spaces per level
+    const twoSpaces = `TELEGRAM_BOT_TOKEN: '849...355:AAG...rgk_YZk...aPU'
+TELEGRAM_ALLOWED_CHATS:
+  -1002975819706
+  -1002861722681
+TELEGRAM_HIVE_OVERRIDES:
+  --all-issues
+  --once
+  --auto-fork
+  --skip-issues-with-prs
+  --attach-logs
+  --verbose
+  --no-tool-check
+TELEGRAM_SOLVE_OVERRIDES:
+  --auto-fork
+  --auto-continue
+  --attach-logs
+  --verbose
+  --no-tool-check
+TELEGRAM_BOT_VERBOSE: true`;
+
+    // Example with 4 spaces per level
+    const fourSpaces = `TELEGRAM_BOT_TOKEN: '849...355:AAG...rgk_YZk...aPU'
+TELEGRAM_ALLOWED_CHATS:
+    -1002975819706
+    -1002861722681
+TELEGRAM_HIVE_OVERRIDES:
+    --all-issues
+    --once
+    --auto-fork
+    --skip-issues-with-prs
+    --attach-logs
+    --verbose
+    --no-tool-check
+TELEGRAM_SOLVE_OVERRIDES:
+    --auto-fork
+    --auto-continue
+    --attach-logs
+    --verbose
+    --no-tool-check
+TELEGRAM_BOT_VERBOSE: true`;
+
+    const resultTwo = parser.parse(twoSpaces);
+    const resultFour = parser.parse(fourSpaces);
+
+    // Compare the entire formatted output (complete round trip test)
+    expect(formatLinks(resultTwo)).toBe(formatLinks(resultFour));
+  });
+
+  test('simple two vs four spaces indentation', () => {
+    // Simple example with 2 spaces
+    const twoSpaces = `parent:
+  child1
+  child2`;
+
+    // Simple example with 4 spaces
+    const fourSpaces = `parent:
+    child1
+    child2`;
+
+    const resultTwo = parser.parse(twoSpaces);
+    const resultFour = parser.parse(fourSpaces);
+
+    // Compare the entire formatted output (complete round trip test)
+    expect(formatLinks(resultTwo)).toBe(formatLinks(resultFour));
+  });
+
+  test('three level nesting with different indentation', () => {
+    // Three levels with 2 spaces
+    const twoSpaces = `level1:
+  level2:
+    level3a
+    level3b
+  level2b`;
+
+    // Three levels with 4 spaces
+    const fourSpaces = `level1:
+    level2:
+        level3a
+        level3b
+    level2b`;
+
+    const resultTwo = parser.parse(twoSpaces);
+    const resultFour = parser.parse(fourSpaces);
+
+    // Compare the entire formatted output (complete round trip test)
+    expect(formatLinks(resultTwo)).toBe(formatLinks(resultFour));
+  });
+});

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)