@futpib/parser 1.0.3 → 1.0.4

package/src/regexpParser.test.ts

@@ -0,0 +1,186 @@
+import test from 'ava';
+import * as fc from 'fast-check';
+import { testProp } from '@fast-check/ava';
+import { runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createRegExpParser } from './regexpParser.js';
+
+test('regexpParser matches digits', async t => {
+	const regexpParser = createRegExpParser(/\d+/);
+
+	const result = await runParser(
+		regexpParser,
+		'123',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '123');
+});
+
+test('regexpParser matches at start only', async t => {
+	const regexpParser = createRegExpParser(/\d+/);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(
+		regexpParser,
+		'123abc',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], '123');
+	t.truthy(remainingInput);
+});
+
+test('regexpParser fails when no match at start', async t => {
+	const regexpParser = createRegExpParser(/\d+/);
+
+	await t.throwsAsync(
+		runParser(
+			regexpParser,
+			'abc123',
+			stringParserInputCompanion,
+		),
+	);
+});
+
+test('regexpParser with capture groups', async t => {
+	const regexpParser = createRegExpParser(/(\d+)-(\d+)/);
+
+	const result = await runParser(
+		regexpParser,
+		'123-456',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '123-456');
+	t.is(result[1], '123');
+	t.is(result[2], '456');
+});
+
+test('regexpParser greedy matching', async t => {
+	const regexpParser = createRegExpParser(/a+/);
+
+	const { output } = await runParserWithRemainingInput(
+		regexpParser,
+		'aaab',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], 'aaa');
+});
+
+test('regexpParser with anchored regexp', async t => {
+	const regexpParser = createRegExpParser(/^hello/);
+
+	const { output } = await runParserWithRemainingInput(
+		regexpParser,
+		'hello world',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], 'hello');
+});
+
+testProp.serial(
+	'regexpParser matches word characters',
+	[
+		fc.tuple(
+			fc.stringMatching(/^\w+$/),
+			fc.stringMatching(/^\W*$/),
+		),
+	],
+	async (t, [ word, nonWord ]) => {
+		const regexpParser = createRegExpParser(/\w+/);
+
+		const { output, position } = await runParserWithRemainingInput(
+			regexpParser,
+			word + nonWord,
+			stringParserInputCompanion,
+		);
+
+		t.is(output[0], word);
+		t.is(position, word.length);
+	},
+	{
+		verbose: true,
+	},
+);
+
+// Tests for zero-width/optional patterns at end of input
+
+test('regexpParser with star quantifier on empty input', async t => {
+	const regexpParser = createRegExpParser(/a*/);
+
+	const result = await runParser(
+		regexpParser,
+		'',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '');
+});
+
+test('regexpParser with optional whitespace on empty input', async t => {
+	const regexpParser = createRegExpParser(/[ \t]*/);
+
+	const result = await runParser(
+		regexpParser,
+		'',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '');
+});
+
+test('regexpParser with star quantifier at end of input (no match)', async t => {
+	const regexpParser = createRegExpParser(/a*/);
+
+	const { output } = await runParserWithRemainingInput(
+		regexpParser,
+		'bbb',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], '');
+});
+
+test('regexpParser with optional group on empty input', async t => {
+	const regexpParser = createRegExpParser(/(?:foo)?/);
+
+	const result = await runParser(
+		regexpParser,
+		'',
+		stringParserInputCompanion,
+	);
+
+	t.is(result[0], '');
+});
+
+// Tests for negative lookahead
+
+test('regexpParser with negative lookahead should not match when followed by same char', async t => {
+	// This regex should NOT match anything in '||' - the | is followed by another |
+	const regexpParser = createRegExpParser(/\|(?!\|)/);
+
+	await t.throwsAsync(
+		runParser(
+			regexpParser,
+			'||',
+			stringParserInputCompanion,
+		),
+	);
+});
+
+test('regexpParser with negative lookahead should match single char', async t => {
+	// This regex should match single '|' when followed by something else
+	const regexpParser = createRegExpParser(/\|(?!\|)/);
+
+	const { output, position, remainingInput } = await runParserWithRemainingInput(
+		regexpParser,
+		'| ',
+		stringParserInputCompanion,
+	);
+
+	t.is(output[0], '|');
+	t.is(position, 1); // Consumed 1 character
+	t.truthy(remainingInput); // There's remaining input (the space)
+});

package/src/regexpParser.ts

@@ -0,0 +1,94 @@
+import { type Parser, setParserName } from './parser.js';
+
+export const createRegExpParser = (
+	regexp: RegExp,
+): Parser<RegExpExecArray, string, string> => {
+	const regexpParser: Parser<RegExpExecArray, string, string> = async parserContext => {
+		let start = 0;
+		let window = 1;
+		let lastMatch: RegExpExecArray | undefined;
+		let reachedEndOfInput = false;
+
+		while (true) {
+			const sequence = await parserContext.peekSequence(start, start + window);
+
+			if (sequence === undefined) {
+				reachedEndOfInput = true;
+				window = Math.floor(window / 2);
+
+				if (window === 0) {
+					// Get the full sequence we've accumulated to verify matches
+					const fullSequence = await parserContext.peekSequence(0, start);
+
+					// Verify any previous match is still valid with full context
+					// For lookahead/lookbehind assertions, additional input might invalidate a match
+					if (fullSequence !== undefined) {
+						const verifyMatch = regexp.exec(fullSequence);
+						if (verifyMatch !== null && verifyMatch.index === 0) {
+							parserContext.skip(verifyMatch[0].length);
+							return verifyMatch;
+						}
+					} else if (lastMatch !== undefined) {
+						// No full sequence available but we have a previous match
+						parserContext.skip(lastMatch[0].length);
+						return lastMatch;
+					}
+
+					// No previous match - try matching against empty string for zero-width patterns (e.g., /a*/, /[ \t]*/)
+					const emptyMatch = regexp.exec('');
+					if (emptyMatch !== null && emptyMatch.index === 0) {
+						return emptyMatch;
+					}
+
+					return parserContext.invariant(false, 'Unexpected end of input without regex match');
+				}
+
+				continue;
+			}
+
+			const fullSequence = await parserContext.peekSequence(0, start + window);
+
+			if (fullSequence === undefined) {
+				continue;
+			}
+
+			const match = regexp.exec(fullSequence);
+
+			if (match === null || match.index !== 0) {
+				if (lastMatch !== undefined) {
+					// Verify lastMatch is still valid with current full context
+					// For lookahead/lookbehind assertions, a match on shorter input might be
+					// invalidated by additional input (e.g., /\|(?!\|)/ matches '|' but not '||')
+					const verifyMatch = regexp.exec(fullSequence);
+					if (verifyMatch !== null && verifyMatch.index === 0) {
+						parserContext.skip(verifyMatch[0].length);
+						return verifyMatch;
+					}
+					// lastMatch was invalidated by additional context
+					lastMatch = undefined;
+				}
+
+				if (reachedEndOfInput) {
+					parserContext.invariant(
+						false,
+						'Regex did not match at start of input',
+					);
+				}
+
+				start += window;
+				window *= 2;
+
+				continue;
+			}
+
+			lastMatch = match;
+
+			start += window;
+			window *= 2;
+		}
+	};
+
+	setParserName(regexpParser, regexp.toString());
+
+	return regexpParser;
+};

package/src/regularExpression.ts

@@ -0,0 +1,24 @@
+export type CodePointRange = {
+	start: number;
+	end: number;
+};
+
+export type CharacterSet =
+	| { type: 'empty' }
+	| { type: 'node'; range: CodePointRange; left: CharacterSet; right: CharacterSet };
+
+export type RepeatBounds = number | { min: number; max?: number } | { min?: number; max: number };
+
+export type RegularExpression =
+	| { type: 'epsilon' }
+	| { type: 'literal'; charset: CharacterSet }
+	| { type: 'concat'; left: RegularExpression; right: RegularExpression }
+	| { type: 'union'; left: RegularExpression; right: RegularExpression }
+	| { type: 'star'; inner: RegularExpression }
+	| { type: 'plus'; inner: RegularExpression }
+	| { type: 'optional'; inner: RegularExpression }
+	| { type: 'repeat'; inner: RegularExpression; bounds: RepeatBounds }
+	| { type: 'capture-group'; inner: RegularExpression; name?: string }
+	| { type: 'lookahead'; isPositive: boolean; inner: RegularExpression; right: RegularExpression }
+	| { type: 'start-anchor'; left: RegularExpression; right: RegularExpression }
+	| { type: 'end-anchor'; left: RegularExpression; right: RegularExpression };

package/src/regularExpressionParser.test.ts

@@ -0,0 +1,102 @@
+import { testProp, fc } from '@fast-check/ava';
+import { regularExpressionParser } from './regularExpressionParser.js';
+
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+
+// Import directly from file path to bypass package exports
+// eslint-disable-next-line import/no-unresolved
+import { parseRegExpString } from '../node_modules/@gruhn/regex-utils/dist/regex-parser.js';
+import { runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
+import type { RegularExpression, CharacterSet } from './regularExpression.js';
+
+// Normalize AST for comparison - removes hashes from CharSets and normalizes structure
+function normalizeCharacterSet(charset: CharacterSet): CharacterSet {
+	if (charset.type === 'empty') {
+		return { type: 'empty' };
+	}
+	return {
+		type: 'node',
+		range: { start: charset.range.start, end: charset.range.end },
+		left: normalizeCharacterSet(charset.left),
+		right: normalizeCharacterSet(charset.right),
+	};
+}
+
+function normalizeRegularExpression(ast: RegularExpression): RegularExpression {
+	switch (ast.type) {
+		case 'epsilon':
+			return { type: 'epsilon' };
+		case 'literal':
+			return { type: 'literal', charset: normalizeCharacterSet(ast.charset) };
+		case 'concat':
+			return { type: 'concat', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+		case 'union':
+			return { type: 'union', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+		case 'star':
+			return { type: 'star', inner: normalizeRegularExpression(ast.inner) };
+		case 'plus':
+			return { type: 'plus', inner: normalizeRegularExpression(ast.inner) };
+		case 'optional':
+			return { type: 'optional', inner: normalizeRegularExpression(ast.inner) };
+		case 'repeat':
+			return { type: 'repeat', inner: normalizeRegularExpression(ast.inner), bounds: ast.bounds };
+		case 'capture-group':
+			if (ast.name !== undefined) {
+				return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner), name: ast.name };
+			}
+			return { type: 'capture-group', inner: normalizeRegularExpression(ast.inner) };
+		case 'lookahead':
+			return { type: 'lookahead', isPositive: ast.isPositive, inner: normalizeRegularExpression(ast.inner), right: normalizeRegularExpression(ast.right) };
+		case 'start-anchor':
+			return { type: 'start-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+		case 'end-anchor':
+			return { type: 'end-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
+	}
+}
+
+// Generate regex patterns that are likely to be supported
+const supportedRegexArbitrary = fc.stringMatching(
+	/^([a-zA-Z0-9]|\\[dDwWsS.]|\[(\^)?([a-zA-Z0-9](-[a-zA-Z0-9])?|\\[dDwWsS])*\]|\.|\((\?[:=!])?[a-zA-Z0-9]*\)|[*+?]|\{[0-9]+(,[0-9]*)?\}|\||\^|\$)*$/,
+).filter(s => {
+	// Filter out patterns that JavaScript doesn't support
+	try {
+		new RegExp(s);
+	} catch {
+		return false;
+	}
+	// Filter out patterns that @gruhn/regex-utils doesn't support
+	try {
+		parseRegExpString(s);
+	} catch {
+		return false;
+	}
+	// Filter out quantified lookaheads - @gruhn/regex-utils has a bug where it treats
+	// quantifiers after lookaheads as literals instead of quantifiers.
+	// See: https://github.com/gruhn/regex-utils/issues/13
+	// JavaScript allows (?=a){2} but @gruhn/regex-utils parses {2} as literal text.
+	if (/\(\?[=!][^)]*\)[*+?]|\(\?[=!][^)]*\)\{[0-9]/.test(s)) {
+		return false;
+	}
+	return true;
+});
+
+testProp(
+	'regularExpressionParser matches @gruhn/regex-utils',
+	[
+		arbitrarilySlicedAsyncIterator(supportedRegexArbitrary),
+	],
+	async (t, [regexStr, regexStringChunkIterator]) => {
+		const expected = normalizeRegularExpression(parseRegExpString(regexStr));
+		const actual = normalizeRegularExpression(await runParser(regularExpressionParser, regexStringChunkIterator, stringParserInputCompanion, {
+			errorJoinMode: 'none',
+		}));
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+		seed,
+	},
+);