links-notation 0.8.0

package/tests/MultilineParser.test.js

@@ -0,0 +1,118 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+const parser = new Parser();
+
+test('TwoLinksTest', () => {
+  const source = `(first: x y)
+(second: a b)`;
+  const links = parser.parse(source);
+  const target = formatLinks(links);
+  expect(target).toBe(source);
+});
+
+test('ParseAndStringifyTest', () => {
+  const source = `(papa (lovesMama: loves mama))
+(son lovesMama)
+(daughter lovesMama)
+(all (love mama))`;
+  const links = parser.parse(source);
+  const target = formatLinks(links);
+  expect(target).toBe(source);
+});
+
+test('ParseAndStringifyTest2', () => {
+  const source = `father (lovesMom: loves mom)
+son lovesMom
+daughter lovesMom
+all (love mom)`;
+  const links = parser.parse(source);
+  const target = formatLinks(links, true); // lessParentheses = true
+  expect(target).toBe(source);
+});
+
+test('ParseAndStringifyWithLessParenthesesTest', () => {
+  const source = `lovesMama: loves mama
+papa lovesMama
+son lovesMama
+daughter lovesMama
+all (love mama)`;
+  const links = parser.parse(source);
+  const target = formatLinks(links, true); // lessParentheses = true
+  expect(target).toBe(source);
+});
+
+test('DuplicateIdentifiersTest', () => {
+  const source = `(a: a b)
+(a: b c)`;
+  const target = `(a: a b)
+(a: b c)`;
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('Test complex structure', () => {
+  const input = `(Type: Type Type)
+  Number
+  String
+  Array
+  Value
+    (property: name type)
+    (method: name params return)`;
+  
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test mixed formats', () => {
+  // Mix of single-line and multi-line formats
+  const input = `id1: value1
+(id2: value2 value3)
+simple_ref
+(complex: 
+  nested1
+  nested2
+)`;
+  
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test multiline with id', () => {
+  // Test multi-line link with id
+  const input = "(id: value1 value2)";
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test multiple top level elements', () => {
+  // Test multiple top-level elements
+  const input = "(elem1: val1)\n(elem2: val2)";
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test multiline simple links', () => {
+  const input = "(1: 1 1)\n(2: 2 2)";
+  const parsed = parser.parse(input);
+  expect(parsed.length).toBeGreaterThan(0);
+  
+  // Validate regular formatting
+  const output = formatLinks(parsed);
+  expect(output).toContain("(1: 1 1)");
+  expect(output).toContain("(2: 2 2)");
+  
+  // Validate alternate formatting matches input
+  const outputAlternate = formatLinks(parsed);
+  expect(outputAlternate).toBe(input);
+});
+
+test('Test indented children', () => {
+  const input = "parent\n  child1\n  child2";
+  const parsed = parser.parse(input);
+  
+  // The parsed structure should have parent with children
+  expect(parsed.length).toBeGreaterThan(0);
+});

package/tests/MultilineQuotedString.test.js

@@ -0,0 +1,78 @@
+import { test, expect } from "bun:test";
+import { Parser } from "../src/Parser.js";
+
+const parser = new Parser();
+
+test("TestMultilineDoubleQuotedReference", () => {
+  const input = `(
+  "long
+string literal representing
+the reference"
+
+  'another
+long string literal
+as another reference'
+)`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe(null);
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(2);
+
+  expect(link.values[0].id).toBe(`long
+string literal representing
+the reference`);
+
+  expect(link.values[1].id).toBe(`another
+long string literal
+as another reference`);
+});
+
+test("TestSimpleMultilineDoubleQuoted", () => {
+  const input = `("line1
+line2")`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe(null);
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(1);
+  expect(link.values[0].id).toBe("line1\nline2");
+});
+
+test("TestSimpleMultilineSingleQuoted", () => {
+  const input = `('line1
+line2')`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe(null);
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(1);
+  expect(link.values[0].id).toBe("line1\nline2");
+});
+
+test("TestMultilineQuotedAsId", () => {
+  const input = `("multi
+line
+id": value1 value2)`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe("multi\nline\nid");
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(2);
+});

package/tests/NestedParser.test.js

@@ -0,0 +1,166 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+const parser = new Parser();
+
+test('SignificantWhitespaceTest', () => {
+  const source = `
+users
+    user1
+        id
+            43
+        name
+            first
+                John
+            last
+                Williams
+        location
+            New York
+        age
+            23
+    user2
+        id
+            56
+        name
+            first
+                Igor
+            middle
+                Petrovich
+            last
+                Ivanov
+        location
+            Moscow
+        age
+            20`;
+
+  const target = `(users)
+((users) (user1))
+(((users) (user1)) (id))
+((((users) (user1)) (id)) (43))
+(((users) (user1)) (name))
+((((users) (user1)) (name)) (first))
+(((((users) (user1)) (name)) (first)) (John))
+((((users) (user1)) (name)) (last))
+(((((users) (user1)) (name)) (last)) (Williams))
+(((users) (user1)) (location))
+((((users) (user1)) (location)) (New York))
+(((users) (user1)) (age))
+((((users) (user1)) (age)) (23))
+((users) (user2))
+(((users) (user2)) (id))
+((((users) (user2)) (id)) (56))
+(((users) (user2)) (name))
+((((users) (user2)) (name)) (first))
+(((((users) (user2)) (name)) (first)) (Igor))
+((((users) (user2)) (name)) (middle))
+(((((users) (user2)) (name)) (middle)) (Petrovich))
+((((users) (user2)) (name)) (last))
+(((((users) (user2)) (name)) (last)) (Ivanov))
+(((users) (user2)) (location))
+((((users) (user2)) (location)) (Moscow))
+(((users) (user2)) (age))
+((((users) (user2)) (age)) (20))`;
+
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('SimpleSignificantWhitespaceTest', () => {
+  const source = `a
+    b
+    c`;
+  const target = `(a)
+((a) (b))
+((a) (c))`;
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('TwoSpacesSizedWhitespaceTest', () => {
+  const source = `
+users
+  user1`;
+  const target = `(users)
+((users) (user1))`;
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('Parse nested structure with indentation', () => {
+  const input = `parent
+  child1
+  child2`;
+  const result = parser.parse(input);
+  expect(result.length).toBe(3);
+  // The parser creates (parent), ((parent) (child1)), ((parent) (child2))
+  expect(result[0].id).toBe(null);
+  expect(result[0].values[0].id).toBe('parent');
+  expect(result[1].id).toBe(null);
+  expect(result[1].values.length).toBe(2);
+  expect(result[2].id).toBe(null);
+  expect(result[2].values.length).toBe(2);
+});
+
+test('Test indentation consistency', () => {
+  // Test that indentation must be consistent
+  const input = `parent
+  child1
+   child2`; // Inconsistent indentation
+  const result = parser.parse(input);
+  // This should parse but child2 won't be a child of parent due to different indentation
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Indentation-based children', () => {
+  const input = `parent
+  child1
+  child2
+    grandchild`;
+  const result = parser.parse(input);
+  expect(result.length).toBe(4);
+});
+
+test('Complex indentation', () => {
+  const input = `root
+  level1a
+    level2a
+    level2b
+  level1b
+    level2c`;
+  const result = parser.parse(input);
+  expect(result.length).toBe(6);
+});
+
+test('Test nested links', () => {
+  const input = '(1: (2: (3: 3)))';
+  const parsed = parser.parse(input);
+  expect(parsed.length).toBeGreaterThan(0);
+
+  // Validate regular formatting
+  const output = formatLinks(parsed);
+  expect(output).toBeTruthy();
+  
+  // Validate that the structure is properly nested
+  expect(parsed.length).toBe(1);
+});
+
+test('Test indentation (parser)', () => {
+  const input = 'parent\n  child1\n  child2';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+  // Should have parent link
+  const hasParentLink = result.some(l => l.values && l.values.some(v => v.id === 'parent'));
+  expect(hasParentLink).toBe(true);
+});
+
+test('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);
+});

package/tests/SingleLineParser.test.js

@@ -0,0 +1,229 @@
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+const parser = new Parser();
+
+test('SingleLinkTest', () => {
+  const source = '(address: source target)';
+  const links = parser.parse(source);
+  const target = formatLinks(links);
+  expect(target).toBe(source);
+});
+
+test('TripletSingleLinkTest', () => {
+  const source = '(papa has car)';
+  const links = parser.parse(source);
+  const target = formatLinks(links);
+  expect(target).toBe(source);
+});
+
+test('BugTest1', () => {
+  const source = '(ignore conan-center-index repository)';
+  const links = parser.parse(source);
+  const target = formatLinks(links);
+  expect(target).toBe(source);
+});
+
+test('QuotedReferencesTest', () => {
+  const source = `(a: 'b' "c")`;
+  const target = `(a: b c)`;
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('QuotedReferencesWithSpacesTest', () => {
+  const source = `('a a': 'b b' "c c")`;
+  const target = `('a a': 'b b' 'c c')`;
+  const links = parser.parse(source);
+  const formattedLinks = formatLinks(links);
+  expect(formattedLinks).toBe(target);
+});
+
+test('Parse simple reference', () => {
+  const input = 'test';
+  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('test');
+  expect(result[0].values[0].values).toEqual([]);
+});
+
+test('Parse reference with colon and values', () => {
+  const input = 'parent: child1 child2';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe('parent');
+  expect(result[0].values.length).toBe(2);
+  expect(result[0].values[0].id).toBe('child1');
+  expect(result[0].values[1].id).toBe('child2');
+});
+
+test('Parse multiline link', () => {
+  const input = '(parent: child1 child2)';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe('parent');
+  expect(result[0].values.length).toBe(2);
+});
+
+test('Parse quoted references', () => {
+  const input = `"has space" 'has:colon'`;
+  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('has space');
+  expect(result[0].values[1].id).toBe('has:colon');
+  // Ensure formatting matches C# expectation
+  expect(formatLinks(result)).toBe(`('has space' 'has:colon')`);
+});
+
+test('Parse values only', () => {
+  const input = ': value1 value2';
+  // Standalone ':' is now forbidden and should throw an error
+  expect(() => parser.parse(input)).toThrow();
+});
+
+test('Test single-line link with id', () => {
+  const input = 'id: value1 value2';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test multi-line link with id', () => {
+  const input = '(id: value1 value2)';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test link without id (single-line)', () => {
+  const input = ': value1 value2';
+  // Standalone ':' is now forbidden and should throw an error
+  expect(() => parser.parse(input)).toThrow();
+});
+
+test('Test link without id (multi-line)', () => {
+  const input = '(: value1 value2)';
+  // '(:)' syntax is now forbidden and should throw an error
+  expect(() => parser.parse(input)).toThrow();
+});
+
+test('Test singlet link', () => {
+  const input = '(singlet)';
+  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('singlet');
+  expect(result[0].values[0].values).toEqual([]);
+});
+
+test('Test value link', () => {
+  const input = '(value1 value2 value3)';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('ParseQuotedReferencesValuesOnly', () => {
+  const source = `"has space" 'has:colon'`;
+  const parser = new Parser();
+  const links = parser.parse(source);
+  expect(links).toBeTruthy();
+  expect(links.length).toBe(1);
+  expect(links[0].id).toBe(null);
+  expect(links[0].values.length).toBe(2);
+  expect(links[0].values[0].id).toBe('has space');
+  expect(links[0].values[1].id).toBe('has:colon');
+});
+
+test('Test quoted references', () => {
+  const input = '("id with spaces": "value with spaces")';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test single-quoted references', () => {
+  const input = "('id': 'value')";
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test nested links', () => {
+  const input = '(outer: (inner: value))';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test special characters in quotes', () => {
+  let input = '("key:with:colons": "value(with)parens")';
+  let result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+  
+  input = "('key with spaces': 'value: with special chars')";
+  result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test deeply nested', () => {
+  const input = '(a: (b: (c: (d: (e: value)))))';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test hyphenated identifiers', () => {
+  const input = '(conan-center-index: repository info)';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test multiple words in quotes', () => {
+  const input = '("New York": city state)';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+  expect(JSON.stringify(result)).toContain('New York');
+});
+
+test('Test simple ref', () => {
+  const input = 'simple_ref';
+  const result = parser.parse(input);
+  expect(result.length).toBeGreaterThan(0);
+});
+
+test('Test simple reference (parser)', () => {
+  const input = 'hello';
+  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('hello');
+});
+
+test('Test quoted reference (parser)', () => {
+  const input = '"hello world"';
+  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('hello world');
+});
+
+test('Test singlet link (parser)', () => {
+  const input = '(singlet)';
+  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('singlet');
+  expect(result[0].values[0].values).toEqual([]);
+});
+
+test('Test value link (parser)', () => {
+  const input = '(a b c)';
+  const result = parser.parse(input);
+  expect(result.length).toBe(1);
+  expect(result[0].id).toBe(null);
+  expect(result[0].values.length).toBe(3);
+});