links-notation 0.28.0 → 0.30.1

package/tests/Comments.test.js

@@ -158,3 +158,34 @@ test('a hash that cannot open a comment is left unquoted', () => {
   expect(Link.escapeReference('#')).toBe("'#'");
   expect(Link.escapeReference('#ff0000')).toBe("'#ff0000'");
 });
+
+// Issue #377: the comment reader and the grammar must agree on where every
+// delimited reference starts and how far it reaches, or a comment is blanked
+// inside what the grammar then reads as a reference.
+
+test('a hash inside a reference that follows a group is content', () => {
+  expect(parsesAs('(a)" #b"\n')).toBe('((<a>) < #b>)');
+});
+
+test('a hash inside a reference that follows another reference is content', () => {
+  expect(parsesAs('"x"\' #y\'\n')).toBe('(<x> < #y>)');
+  expect(parsesAs('```q```"" #c\n"""\n')).toBe('(<q> < #c\n">)');
+});
+
+test('a hash inside a reference that follows a literal is content', () => {
+  expect(parsesAs('~1{62}" #b"\n')).toBe('(<b> < #b>)');
+});
+
+test('a reference is read in the document as written, comments included', () => {
+  // The body of the first `""` straddles a parenthesis, so it is the empty
+  // reference and the `#` after it opens a comment. Blanking that comment
+  // must not turn the `""` into a reference that holds the blanked text.
+  expect(parsesAs('"" a #)b\n""\n')).toBe('(<> <a>)\n(<>)');
+});
+
+test('the comment reader skips the references the grammar reads', () => {
+  expect(stripComments('(a)" #b"\n')).toBe('(a)" #b"\n');
+  expect(stripComments('"x"\' #y\'\n')).toBe('"x"\' #y\'\n');
+  expect(stripComments('~1{62}" #b"\n')).toBe('~1{62}" #b"\n');
+  expect(stripComments('a"b #c"\n')).toBe('a"b    \n');
+});

package/tests/SharedTextParity.test.js

@@ -1,7 +1,13 @@
 import { readFileSync } from 'node:fs';
 import { URL } from 'node:url';
 import { expect, test } from 'bun:test';
-import { Parser, StreamParser, formatLinks } from '../src/index.js';
+import {
+  FormatOptions,
+  Link,
+  Parser,
+  StreamParser,
+  formatLinks,
+} from '../src/index.js';
 
 const fixtures = JSON.parse(
   readFileSync(
@@ -25,3 +31,49 @@ test('shared text parity', () => {
     expect(tree(stream.end()), fixture.id).toEqual(fixture.expected);
   }
 });
+
+test('shared less parentheses round trip', () => {
+  const options = new FormatOptions({ lessParentheses: true });
+  for (const fixture of fixtures) {
+    const parsed = new Parser().parse(fixture.input);
+    expect(formatLinks(parsed, true), fixture.id).toBe(fixture.lessParentheses);
+    expect(formatLinks(parsed, options), fixture.id).toBe(
+      fixture.lessParentheses
+    );
+    expect(
+      tree(new Parser().parse(fixture.lessParentheses)),
+      fixture.id
+    ).toEqual(fixture.expected);
+    for (const link of parsed) {
+      const [readBack] = new Parser().parse(link.format(true));
+      expect(link.equals(readBack), fixture.id).toBe(true);
+    }
+  }
+});
+
+test('less parentheses keeps the parentheses of a lone nested value', () => {
+  const nested = new Link(null, [new Link('b'), new Link('c')]);
+  expect(new Link(null, [nested]).format(true)).toBe('((b c))');
+  expect(new Link(null, [new Link('b')]).format(true)).toBe('b');
+  expect(new Link(null, [new Link('a'), nested]).format(true)).toBe('a (b c)');
+});
+
+test('less parentheses keeps the parentheses of an empty link', () => {
+  const options = new FormatOptions({ lessParentheses: true });
+  expect(new Link(null, []).format(true)).toBe('()');
+  expect(new Link(null, []).format(options)).toBe('()');
+  expect(formatLinks([], true)).toBe('');
+});
+
+test('line length is measured on the parentheses a lone nested value keeps', () => {
+  const link = new Link(null, [new Link(null, [new Link('b'), new Link('c')])]);
+  const options = (maxLineLength) =>
+    new FormatOptions({
+      lessParentheses: true,
+      indentLongLines: true,
+      maxLineLength,
+      preferInline: false,
+    });
+  expect(link.format(options(7))).toBe('((b c))');
+  expect(link.format(options(6))).toBe('  (b c)');
+});

package/tests/StreamParser.test.js

@@ -162,4 +162,17 @@ describe('StreamParser', () => {
       buffered: 2,
     });
   });
+
+  test('waits for the line that closes an even run of quotes (issue #377)', () => {
+    // `""` is the empty reference only when nothing closes it, and here the
+    // next line does, so the first line cannot be emitted on its own.
+    const input = 'a "" b\n"" c\n';
+    const stream = new StreamParser();
+    for (const character of input) {
+      expect(stream.write(character)).toEqual([]);
+    }
+    expect(formatLinks(stream.end())).toBe(
+      formatLinks(new Parser().parse(input))
+    );
+  });
 });