links-notation 0.8.0

package/tests/ApiTests.test.js

@@ -0,0 +1,74 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { Link } from '../src/Link.js';
+
+const parser = new Parser();
+
+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');
+  expect(simpleLink.id).toBe('some_value');
+  expect(simpleLink.values).toEqual([]);
+});
+
+test('test_is_link equivalent', () => {
+  // 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_empty_link', () => {
+  const link = new Link(null, []);
+  const output = link.toString();
+  expect(output).toBe('()');
+});
+
+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
+  expect(output).toBe(expected);
+});
+
+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);
+});
+
+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);
+});
+
+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');
+  expect(output).toContain('value1');
+  expect(output).toContain('value2');
+});
+
+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');
+});

package/tests/EdgeCaseParser.test.js

@@ -0,0 +1,162 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+const parser = new Parser();
+
+test('EmptyLinkTest', () => {
+  const source = ':';
+  // Standalone ':' is now forbidden and should throw an error
+  expect(() => parser.parse(source)).toThrow();
+});
+
+test('EmptyLinkWithParenthesesTest', () => {
+  const source = '()';
+  const target = '()';
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('EmptyLinkWithEmptySelfReferenceTest', () => {
+  const source = '(:)';
+  // '(:)' is now forbidden and should throw an error
+  expect(() => parser.parse(source)).toThrow();
+});
+
+test('TestAllFeaturesTest', () => {
+  // Test single-line link with id
+  let input = 'id: value1 value2';
+  let result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+
+  // Test multi-line link with id
+  input = '(id: value1 value2)';
+  result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+
+  // Test link without id (single-line) - now forbidden
+  input = ': value1 value2';
+  expect(() => parser.parse(input)).toThrow();
+
+  // Test link without id (multi-line) - now forbidden
+  input = '(: value1 value2)';
+  expect(() => parser.parse(input)).toThrow();
+
+  // Test singlet link
+  input = '(singlet)';
+  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('singlet');
+  expect(result[0].values[0].values).toEqual([]);
+
+  // Test value link
+  input = '(value1 value2 value3)';
+  result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+
+  // Test quoted references
+  input = '("id with spaces": "value with spaces")';
+  result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+
+  // Test single-quoted references
+  input = "('id': 'value')";
+  result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+
+  // Test nested links
+  input = '(outer: (inner: value))';
+  result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('TestEmptyDocumentTest', () => {
+  const input = '';
+  // Empty document should return empty array
+  const result = parser.parse(input);
+  expect(result).toEqual([]);
+});
+
+test('TestWhitespaceOnlyTest', () => {
+  const input = '   \n   \n   ';
+  // Whitespace-only document should return empty array
+  const result = parser.parse(input);
+  expect(result).toEqual([]);
+});
+
+test('TestEmptyLinksTest', () => {
+  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);
+  expect(result[0].id).toBe('id');
+  expect(result[0].values).toEqual([]);
+});
+
+test('TestSingletLinksTest', () => {
+  // Test singlet (1)
+  let input = '(1)';
+  let 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('1');
+  expect(result[0].values[0].values).toEqual([]);
+
+  // Test (1 2)
+  input = '(1 2)';
+  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('1');
+  expect(result[0].values[0].values).toEqual([]);
+  expect(result[0].values[1].id).toBe('2');
+  expect(result[0].values[1].values).toEqual([]);
+
+  // Test (1 2 3)
+  input = '(1 2 3)';
+  result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe(null);
+  expect(result[0].values.length).toBe(3);
+  expect(result[0].values[0].id).toBe('1');
+  expect(result[0].values[0].values).toEqual([]);
+  expect(result[0].values[1].id).toBe('2');
+  expect(result[0].values[1].values).toEqual([]);
+  expect(result[0].values[2].id).toBe('3');
+  expect(result[0].values[2].values).toEqual([]);
+
+  // Test (1 2 3 4)
+  input = '(1 2 3 4)';
+  result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe(null);
+  expect(result[0].values.length).toBe(4);
+  expect(result[0].values[0].id).toBe('1');
+  expect(result[0].values[0].values).toEqual([]);
+  expect(result[0].values[1].id).toBe('2');
+  expect(result[0].values[1].values).toEqual([]);
+  expect(result[0].values[2].id).toBe('3');
+  expect(result[0].values[2].values).toEqual([]);
+  expect(result[0].values[3].id).toBe('4');
+  expect(result[0].values[3].values).toEqual([]);
+});
+
+test('TestInvalidInputTest', () => {
+  const input = '(invalid';
+  // Unclosed parentheses should throw an error
+  expect(() => parser.parse(input)).toThrow();
+});

package/tests/IndentedIdSyntax.test.js

@@ -0,0 +1,171 @@
+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", () => {
+  const indentedSyntax = `3:
+  papa
+  loves
+  mama`;
+
+  const inlineSyntax = "(3: papa loves mama)";
+
+  const indentedResult = parser.parse(indentedSyntax);
+  const inlineResult = parser.parse(inlineSyntax);
+
+  // Both should produce identical structures
+  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)");
+});
+
+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(result.length).toBe(1);
+  expect(result[0].id).toBe("greeting");
+  expect(result[0].values.length).toBe(1);
+  expect(result[0].values[0].id).toBe("hello");
+});
+
+test("Indented ID syntax with multiple values", () => {
+  const input = `action:
+  run
+  fast
+  now`;
+
+  const result = parser.parse(input);
+  const formatted = formatLinks(result);
+
+  expect(formatted).toBe("(action: run fast now)");
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe("action");
+  expect(result[0].values.length).toBe(3);
+});
+
+test("Indented ID syntax with numeric ID", () => {
+  const input = `42:
+  answer
+  to
+  everything`;
+
+  const result = parser.parse(input);
+  const formatted = formatLinks(result);
+
+  expect(formatted).toBe("(42: answer to everything)");
+});
+
+test("Indented ID syntax with quoted ID", () => {
+  const input = `"complex id":
+  value1
+  value2`;
+
+  const result = parser.parse(input);
+  const formatted = formatLinks(result);
+
+  expect(formatted).toBe("('complex id': value1 value2)");
+});
+
+test("Multiple indented ID links", () => {
+  const input = `first:
+  a
+  b
+second:
+  c
+  d`;
+
+  const result = parser.parse(input);
+  const formatted = formatLinks(result);
+
+  expect(result.length).toBe(2);
+  expect(formatted).toBe("(first: a b)\n(second: c d)");
+});
+
+test("Mixed indented and regular syntax", () => {
+  const input = `first:
+  a
+  b
+(second: c d)
+third value`;
+
+  const result = parser.parse(input);
+  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");
+});
+
+test("Unsupported colon-only syntax should fail", () => {
+  const input = `:
+  papa
+  loves
+  mama`;
+
+  expect(() => {
+    parser.parse(input);
+  }).toThrow();
+});
+
+test("Indented ID with deeper nesting", () => {
+  const input = `root:
+  child1
+  child2
+    grandchild`;
+
+  // This should work but the grandchild will be processed as a separate nested structure
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+
+  // The root should have child1 and child2 as values
+  const rootLink = result[0];
+  expect(rootLink.id).toBe("root");
+  expect(rootLink.values.length).toBe(2);
+});
+
+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].values.length).toBe(0);
+
+  const formatted = formatLinks(result);
+  expect(formatted).toBe("(empty)");
+});
+
+test("Equivalence test - comprehensive", () => {
+  const testCases = [
+    {
+      indented: "test:\n  one",
+      inline: "(test: one)"
+    },
+    {
+      indented: "x:\n  a\n  b\n  c",
+      inline: "(x: a b c)"
+    },
+    {
+      indented: "\"quoted\":\n  value",
+      inline: "(\"quoted\": value)"
+    }
+  ];
+
+  for (const testCase of testCases) {
+    const indentedResult = parser.parse(testCase.indented);
+    const inlineResult = parser.parse(testCase.inline);
+
+    expect(indentedResult).toEqual(inlineResult);
+    expect(formatLinks(indentedResult)).toBe(formatLinks(inlineResult));
+  }
+});

package/tests/Link.test.js

@@ -0,0 +1,69 @@
+import { test, expect } from 'bun:test';
+import { Link } from '../src/Link.js';
+
+test('Link constructor with id only', () => {
+  const link = new Link('test');
+  expect(link.id).toBe('test');
+  expect(link.values).toEqual([]);
+});
+
+test('Link constructor with id and values', () => {
+  const link = new Link('parent', [new Link('child1'), new Link('child2')]);
+  expect(link.id).toBe('parent');
+  expect(link.values.length).toBe(2);
+  expect(link.values[0].id).toBe('child1');
+  expect(link.values[1].id).toBe('child2');
+});
+
+test('Link toString with id only', () => {
+  const link = new Link('test');
+  expect(link.toString()).toBe('(test)');
+});
+
+test('Link toString with values only', () => {
+  const link = new Link(null, [new Link('value1'), new Link('value2')]);
+  expect(link.toString()).toBe('(value1 value2)');
+});
+
+test('Link toString with id and values', () => {
+  const link = new Link('parent', [new Link('child1'), new Link('child2')]);
+  expect(link.toString()).toBe('(parent: child1 child2)');
+});
+
+test('Link escapeReference for simple reference', () => {
+  expect(Link.escapeReference('simple')).toBe('simple');
+});
+
+test('Link escapeReference with special characters', () => {
+  expect(Link.escapeReference('has:colon')).toBe("'has:colon'");
+  expect(Link.escapeReference('has space')).toBe("'has space'");
+  expect(Link.escapeReference('has(paren)')).toBe("'has(paren)'");
+  expect(Link.escapeReference('has"quote')).toBe(`'has"quote'`);
+  expect(Link.escapeReference("has'quote")).toBe(`"has'quote"`);
+});
+
+test('Link simplify', () => {
+  const link = new Link(null, [new Link('single')]);
+  const simplified = link.simplify();
+  expect(simplified.id).toBe('single');
+  expect(simplified.values).toEqual([]);
+});
+
+test('Link combine', () => {
+  const link1 = new Link('first');
+  const link2 = new Link('second');
+  const combined = link1.combine(link2);
+  expect(combined.id).toBe(null);
+  expect(combined.values.length).toBe(2);
+  expect(combined.values[0].id).toBe('first');
+  expect(combined.values[1].id).toBe('second');
+});
+
+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

@@ -0,0 +1,40 @@
+import { test, expect } from 'bun:test';
+import { LinksGroup } from '../src/LinksGroup.js';
+import { Link } from '../src/Link.js';
+
+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);
+});
+
+test('LinksGroup toList flattens structure', () => {
+  const root = new Link('root');
+  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);
+  expect(list[1]).toBe(child1);
+  expect(list[2]).toBe(child2);
+  expect(list[3]).toBe(grandchild);
+});
+
+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)');
+});

package/tests/MixedIndentationModes.test.js

@@ -0,0 +1,188 @@
+import { test, expect } from "bun:test";
+import { Parser } from "../src/Parser.js";
+import { formatLinks } from "../src/Link.js";
+
+const parser = new Parser();
+
+test("Hero example - mixed modes - issue #105", () => {
+  const input = `empInfo
+  employees:
+    (
+      name (James Kirk)
+      age 40
+    )
+    (
+      name (Jean-Luc Picard)
+      age 45
+    )
+    (
+      name (Wesley Crusher)
+      age 27
+    )`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("empInfo");
+  expect(formatted).toContain("employees:");
+  expect(formatted).toContain("James Kirk");
+  expect(formatted).toContain("Jean-Luc Picard");
+  expect(formatted).toContain("Wesley Crusher");
+});
+
+test("Hero example - alternative format - issue #105", () => {
+  const input = `empInfo
+  (
+    employees:
+      (
+        name (James Kirk)
+        age 40
+      )
+      (
+        name (Jean-Luc Picard)
+        age 45
+      )
+      (
+        name (Wesley Crusher)
+        age 27
+      )
+  )`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("empInfo");
+  expect(formatted).toContain("employees:");
+  expect(formatted).toContain("James Kirk");
+  expect(formatted).toContain("Jean-Luc Picard");
+  expect(formatted).toContain("Wesley Crusher");
+});
+
+test("Hero example - equivalence test - issue #105", () => {
+  const version1 = `empInfo
+  employees:
+    (
+      name (James Kirk)
+      age 40
+    )
+    (
+      name (Jean-Luc Picard)
+      age 45
+    )
+    (
+      name (Wesley Crusher)
+      age 27
+    )`;
+
+  const version2 = `empInfo
+  (
+    employees:
+      (
+        name (James Kirk)
+        age 40
+      )
+      (
+        name (Jean-Luc Picard)
+        age 45
+      )
+      (
+        name (Wesley Crusher)
+        age 27
+      )
+  )`;
+
+  const result1 = parser.parse(version1);
+  const result2 = parser.parse(version2);
+
+  const formatted1 = formatLinks(result1);
+  const formatted2 = formatLinks(result2);
+
+  expect(formatted1).toBe(formatted2);
+});
+
+test("Set/object context without colon", () => {
+  const input = `empInfo
+  employees`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("empInfo");
+  expect(formatted).toContain("employees");
+});
+
+test("Sequence/list context with colon", () => {
+  const input = `employees:
+  James Kirk
+  Jean-Luc Picard
+  Wesley Crusher`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("employees:");
+  expect(formatted).toContain("James Kirk");
+  expect(formatted).toContain("Jean-Luc Picard");
+  expect(formatted).toContain("Wesley Crusher");
+});
+
+test("Sequence context with complex values", () => {
+  const input = `employees:
+  (
+    name (James Kirk)
+    age 40
+  )
+  (
+    name (Jean-Luc Picard)
+    age 45
+  )`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("employees:");
+  expect(formatted).toContain("James Kirk");
+  expect(formatted).toContain("Jean-Luc Picard");
+});
+
+test("Nested set and sequence contexts", () => {
+  const input = `company
+  departments:
+    engineering
+    sales
+  employees:
+    (name John)
+    (name Jane)`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("company");
+  expect(formatted).toContain("departments:");
+  expect(formatted).toContain("employees:");
+});
+
+test("Deeply nested mixed modes", () => {
+  const input = `root
+  level1
+    level2:
+      value1
+      value2
+    level2b
+      level3`;
+
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  const formatted = formatLinks(result);
+  expect(formatted).toContain("root");
+  expect(formatted).toContain("level2:");
+});