links-notation 0.21.2 → 0.22.0

package/tests/NestingDepth.test.js

@@ -0,0 +1,124 @@
+// Reading nested groups must take time that grows with the size of the
+// document, not with two to the power of its nesting depth
+// (https://github.com/link-foundation/links-notation/issues/314).
+//
+// Before the fix, every level of nesting doubled the work: a nine-byte document
+// took seconds. Each case is parsed on its own thread and fails when it has not
+// finished within the budget, so a regression fails instead of hanging.
+
+import { test, expect } from 'bun:test';
+import { clearTimeout, setTimeout } from 'node:timers';
+import { URL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+// Generous enough for a slow machine, and far below what the exponential
+// reading took at the depths used here.
+const BUDGET_MS = 5000;
+
+// The depth used for the shapes that used to take exponential time.
+const DEEP = 32;
+
+// A depth that shows the time grows with the size of the document.
+const VERY_DEEP = 256;
+
+function withinBudget(what, source) {
+  const worker = new Worker(
+    new URL('./support/nestingDepthWorker.js', import.meta.url)
+  );
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`${what} did not finish within ${BUDGET_MS} ms`)),
+      BUDGET_MS
+    );
+  });
+  const result = new Promise((resolve, reject) => {
+    worker.once('message', resolve);
+    worker.once('error', reject);
+  });
+  worker.postMessage(source);
+  return Promise.race([result, timeout]).finally(() => {
+    clearTimeout(timer);
+    worker.terminate();
+  });
+}
+
+const closed = (depth) => `${'('.repeat(depth)}a${')'.repeat(depth)}`;
+
+const valueAfter = (depth) => `${'('.repeat(depth)}a${') b'.repeat(depth)}`;
+
+const unclosed = (depth) => `${'('.repeat(depth)}a`;
+
+// Unclosed groups on lines that are each indented one space deeper.
+const indentedUnclosed = (depth) =>
+  Array.from({ length: depth }, (_, level) => `${' '.repeat(level)}(a`).join(
+    '\n'
+  );
+
+test(
+  'closed groups read in linear time',
+  async () => {
+    const source = closed(DEEP);
+    const result = await withinBudget('closed groups', source);
+    expect(result).toEqual({ formatted: source });
+  },
+  BUDGET_MS * 2
+);
+
+test(
+  'values after groups read in linear time',
+  async () => {
+    const source = valueAfter(DEEP);
+    const result = await withinBudget('values after groups', source);
+    expect(result).toEqual({ formatted: `(${source})` });
+  },
+  BUDGET_MS * 2
+);
+
+test(
+  'unclosed groups fail in linear time',
+  async () => {
+    const result = await withinBudget('unclosed groups', unclosed(DEEP));
+    expect(result).toEqual({ error: 'ParseError' });
+  },
+  BUDGET_MS * 2
+);
+
+test(
+  'unclosed groups on indented lines fail in linear time',
+  async () => {
+    const result = await withinBudget(
+      'unclosed indented groups',
+      indentedUnclosed(DEEP)
+    );
+    expect(result).toEqual({ error: 'ParseError' });
+  },
+  BUDGET_MS * 2
+);
+
+test(
+  'values after very deep groups read in linear time',
+  async () => {
+    const source = valueAfter(VERY_DEEP);
+    const result = await withinBudget('very deep values after groups', source);
+    expect(result).toEqual({ formatted: `(${source})` });
+  },
+  BUDGET_MS * 2
+);
+
+test('group followed by values keeps its structure', () => {
+  const cases = [
+    ['(a) b', '((a) b)'],
+    ['(a) (b) c', '((a) (b) c)'],
+    ['((a) b) c', '(((a) b) c)'],
+    ['(a: b) c', '((a: b) c)'],
+    ['(a)\n(b) c', '(a)\n((b) c)'],
+    ['x\n  (a) b\n  (c)', '(x)\n((x) ((a) b))\n((x) (c))'],
+  ];
+  const parser = new Parser();
+  for (const [source, expected] of cases) {
+    expect(formatLinks(parser.parse(source))).toBe(expected);
+  }
+});

package/tests/NestingLimit.test.js

@@ -0,0 +1,132 @@
+// Links nested too deeply are refused with an error rather than recursed into
+// until the stack overflows
+// (https://github.com/link-foundation/links-notation/issues/315).
+//
+// Every parenthesized group and every indentation level is one level, and the
+// lines of a document start at level 0. The positions asserted here are the
+// ones the Rust port reports for the same input.
+
+import { test, expect } from 'bun:test';
+import {
+  Parser,
+  ParseError,
+  StreamParser,
+  StreamParseError,
+  DEFAULT_MAX_DEPTH,
+} from '../src/index.js';
+
+const parens = (depth) => '('.repeat(depth) + 'a' + ')'.repeat(depth);
+
+const values = (depth) => '(a '.repeat(depth) + 'b' + ')'.repeat(depth);
+
+const indentation = (depth) =>
+  Array.from(
+    { length: depth + 1 },
+    (_, level) => ' '.repeat(level) + 'a\n'
+  ).join('');
+
+function tooDeep(document, maxDepth) {
+  try {
+    const links = new Parser({ maxDepth }).parse(document);
+    throw new Error(
+      `expected ${JSON.stringify(document)} to be too deep, got ${links.length} links`
+    );
+  } catch (error) {
+    expect(error).toBeInstanceOf(ParseError);
+    expect(error.maxDepth).toBe(maxDepth);
+    return error;
+  }
+}
+
+const accepted = (document, maxDepth) =>
+  new Parser({ maxDepth }).parse(document).length > 0;
+
+test('the default limit is shared by every implementation', () => {
+  expect(DEFAULT_MAX_DEPTH).toBe(64);
+  expect(new Parser().maxDepth).toBe(DEFAULT_MAX_DEPTH);
+});
+
+test('parentheses up to the limit are accepted', () => {
+  expect(accepted(parens(3), 3)).toBe(true);
+  expect(accepted(values(3), 3)).toBe(true);
+});
+
+test('parentheses past the limit are refused at the group that is too deep', () => {
+  const error = tooDeep(parens(4), 3);
+
+  expect([error.line, error.column, error.offset]).toEqual([1, 4, 3]);
+  expect(error.message).toBe(
+    'Nesting too deep at line 1, column 4: nesting depth exceeds the maximum of 3\n' +
+      '1 | ((((a))))\n' +
+      '  |    ^'
+  );
+});
+
+test('groups in value position count like any other group', () => {
+  const error = tooDeep(values(4), 3);
+
+  expect([error.line, error.column]).toEqual([1, 10]);
+});
+
+test('indentation up to the limit is accepted', () => {
+  expect(accepted(indentation(3), 3)).toBe(true);
+  expect(accepted(indentation(DEFAULT_MAX_DEPTH), undefined)).toBe(true);
+});
+
+test('indentation past the limit is refused at the line that is too deep', () => {
+  const error = tooDeep(indentation(4), 3);
+
+  expect([error.line, error.column]).toEqual([5, 5]);
+  expect(error.lineText).toBe('    a');
+});
+
+test('groups and indentation add up', () => {
+  // `(b)` on the line indented once is at level 2.
+  expect(accepted('a\n  (b)\n', 2)).toBe(true);
+  const error = tooDeep('a\n  (b)\n', 1);
+
+  expect([error.line, error.column]).toEqual([2, 3]);
+});
+
+test('trailing spaces on a deep line are not a deeper line', () => {
+  expect(accepted('a\n  b\n    c   \n', 2)).toBe(true);
+});
+
+test('a syntax error is not mistaken for nesting that is too deep', () => {
+  try {
+    new Parser().parse('a: b: c');
+    throw new Error('expected a syntax error');
+  } catch (error) {
+    expect(error).toBeInstanceOf(ParseError);
+    expect(error.maxDepth).toBeNull();
+    expect(error.message).toStartWith('Syntax error at ');
+  }
+});
+
+test('refuses a document far past the limit instead of overflowing the stack', () => {
+  // Before the limit existed each of these ran out of stack.
+  for (const document of [
+    parens(100_000),
+    values(100_000),
+    indentation(2_000),
+  ]) {
+    const error = tooDeep(document, DEFAULT_MAX_DEPTH);
+    expect(error.message).toStartWith('Nesting too deep at ');
+  }
+});
+
+test('the stream parser reports where the nesting is too deep', () => {
+  const stream = new StreamParser({ maxDepth: 1 });
+  stream.write('a\nb ((c))\n');
+
+  let error;
+  try {
+    stream.end();
+  } catch (thrown) {
+    error = thrown;
+  }
+
+  expect(error).toBeInstanceOf(StreamParseError);
+  expect(error.cause.maxDepth).toBe(1);
+  expect([error.line, error.column, error.offset]).toEqual([2, 4, 5]);
+});

package/tests/support/nestingDepthWorker.js

@@ -0,0 +1,17 @@
+// Parses the documents it is sent on its own thread, so a test can stop a
+// parse that takes too long instead of hanging.
+import { parentPort } from 'node:worker_threads';
+import { Parser } from '../../src/Parser.js';
+import { formatLinks } from '../../src/Link.js';
+
+// The documents nest deeper than the default limit on purpose; only the time
+// they take is measured here.
+const parser = new Parser({ maxDepth: Infinity });
+
+parentPort.on('message', (source) => {
+  try {
+    parentPort.postMessage({ formatted: formatLinks(parser.parse(source)) });
+  } catch (error) {
+    parentPort.postMessage({ error: error.name });
+  }
+});