@futpib/parser 1.0.0 → 1.0.2

package/src/negativeLookaheadParser.ts

@@ -0,0 +1,36 @@
+import { getParserName, setParserName, type Parser } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+
+export const createNegativeLookaheadParser = <Sequence>(
+	childParser: Parser<unknown, Sequence>,
+): Parser<void, Sequence> => {
+	const negativeLookaheadParser: Parser<void, Sequence> = async parserContext => {
+		const childParserContext = parserContext.lookahead();
+
+		let childParserSuccess: boolean;
+
+		try {
+			await childParser(childParserContext);
+
+			childParserSuccess = true;
+		} catch (error) {
+			if (!(error instanceof ParserParsingFailedError)) {
+				throw error;
+			}
+
+			childParserSuccess = false;
+		} finally {
+			childParserContext.dispose();
+		}
+
+		parserContext.invariant(
+			!childParserSuccess,
+			'Negative lookahead assertion failed for child parser %s.',
+			getParserName(childParser),
+		);
+	};
+
+	setParserName(negativeLookaheadParser, `(?!${getParserName(childParser)})`);
+
+	return negativeLookaheadParser;
+};

package/src/nonEmptyArrayParser.test.ts

@@ -0,0 +1,20 @@
+import test from 'ava';
+import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
+import { type Parser, runParser } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactElementParser } from './exactElementParser.js';
+
+test('empty array does not match', async t => {
+	const parser: Parser<string[], string> = createNonEmptyArrayParser(createExactElementParser('0'));
+
+	await t.throwsAsync(() => runParser(parser, '', stringParserInputCompanion), {
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('non-empty array matches', async t => {
+	const parser: Parser<string[], string> = createNonEmptyArrayParser(createExactElementParser('0'));
+	const result = await runParser(parser, '0', stringParserInputCompanion);
+
+	t.deepEqual(result, ['0']);
+});

package/src/nonEmptyArrayParser.ts

@@ -0,0 +1,44 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
+
+export const createNonEmptyArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const nonEmptyArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementParserContext = parserContext.lookahead();
+			const initialPosition = elementParserContext.position;
+			try {
+				const element = await elementParser(elementParserContext);
+				if (elementParserContext.position === initialPosition) {
+					break;
+				}
+
+				elements.push(element);
+				elementParserContext.unlookahead();
+			} catch (error) {
+				if (error instanceof ParserParsingFailedError) {
+					break;
+				}
+
+				throw error;
+			} finally {
+				elementParserContext.dispose();
+			}
+		}
+
+		parserContext.invariant(
+			elements.length > 0,
+			'Expected elementParser (%s) to match at least once',
+			getParserName(elementParser, 'anonymousNonEmptyArrayChild'),
+		);
+
+		return elements;
+	};
+
+	setParserName(nonEmptyArrayParser, getParserName(elementParser, 'anonymousNonEmptyArrayChild') + '+');
+
+	return nonEmptyArrayParser;
+};

package/src/optionalParser.ts

@@ -1,11 +1,12 @@
-import { getParserName, Parser, setParserName } from "./parser.js";
-import { ParserParsingFailedError } from "./parserError.js";
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { ParserParsingFailedError } from './parserError.js';
 
 export const createOptionalParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
 ): Parser<undefined | Output, Sequence> => {
 	const optionalParser: Parser<undefined | Output, Sequence> = async parserContext => {
 		const childParserContext = parserContext.lookahead();
+
 		try {
 			const value = await childParser(childParserContext);
 			childParserContext.unlookahead();
@@ -24,4 +25,4 @@ export const createOptionalParser = <Output, Sequence>(
 	setParserName(optionalParser, getParserName(childParser, 'anonymousOptionalChild') + '?');
 
 	return optionalParser;
-}
+};

package/src/parser.test.ts

@@ -1,34 +1,44 @@
 import test from 'ava';
+import invariant from 'invariant';
 import { createUnionParser } from './unionParser.js';
-import { Parser, runParser } from './parser.js';
-import { stringInputCompanion, uint8ArrayInputCompanion } from './inputCompanion.js';
-import { ParserParsingInvariantError, ParserParsingJoinAllError, ParserParsingJoinDeepestError, ParserParsingJoinError, ParserParsingJoinFurthestError, ParserParsingJoinNoneError } from './parserError.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion, uint8ArrayParserInputCompanion } from './parserInputCompanion.js';
+import {
+	ParserError,
+	ParserParsingInvariantError,
+	ParserParsingJoinAllError,
+	ParserParsingJoinDeepestError,
+	ParserParsingJoinError,
+	ParserParsingJoinFurthestError,
+	ParserParsingJoinNoneError,
+	ParserUnexpectedRemainingInputError,
+} from './parserError.js';
 import { createTupleParser } from './tupleParser.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createDisjunctionParser } from './disjunctionParser.js';
-import invariant from 'invariant';
-import { createExactSequenceParser } from './exactSequenceParser.js';
+import { createExactSequenceNaiveParser } from './exactSequenceParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
+import { toAsyncIterable } from './toAsyncIterable.js';
 
 const aUnionParser = createUnionParser<string, string>([
-	createExactSequenceParser('1'),
-	createExactSequenceParser('aa'),
-	createExactSequenceParser('AAA'),
+	createExactSequenceNaiveParser('1'),
+	createExactSequenceNaiveParser('aa'),
+	createExactSequenceNaiveParser('AAA'),
 ]);
 
 const abDisjunctionParser = createDisjunctionParser<string, string>([
 	aUnionParser,
-	createExactSequenceParser('2'),
-	createExactSequenceParser('bb'),
-	createExactSequenceParser('BBB'),
+	createExactSequenceNaiveParser('2'),
+	createExactSequenceNaiveParser('bb'),
+	createExactSequenceNaiveParser('BBB'),
 ]);
 
 const abcUnionParser = createUnionParser<string, string>([
 	abDisjunctionParser,
-	createExactSequenceParser('final_3'),
-	createExactSequenceParser('final_cc'),
-	createExactSequenceParser('final_CCC'),
+	createExactSequenceNaiveParser('final_3'),
+	createExactSequenceNaiveParser('final_cc'),
+	createExactSequenceNaiveParser('final_CCC'),
 ]);
 
 const sampleParser = promiseCompose(
@@ -44,6 +54,16 @@ async function * asyncIteratorFromString(string: string) {
 	yield string;
 }
 
+async function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>) {
+	let string = '';
+
+	for await (const chunk of asyncIterable) {
+		string += chunk;
+	}
+
+	return string;
+}
+
 function sortChildErrors(error: ParserParsingJoinNoneError) {
 	error.childErrors.sort((a, b) => a.message.localeCompare(b.message));
 
@@ -55,14 +75,14 @@ function sortChildErrors(error: ParserParsingJoinNoneError) {
 }
 
 function removeStackLocations(errorStack: string) {
-	return errorStack.replace(/((at [^\n]+)[\s\n]+)+(at [^\n]+)/g, 'at [LOCATIONS]');
+	return errorStack.replaceAll(/((at [^\n]+)[\s\n]+)+(at [^\n]+)/g, 'at [LOCATIONS]');
 }
 
 test('errorJoinMode: none', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'none',
 	}), {
-		instanceOf: ParserParsingJoinNoneError
+		instanceOf: ParserParsingJoinNoneError,
 	});
 
 	t.is(error.position, 12);
@@ -72,10 +92,10 @@ test('errorJoinMode: none', async t => {
 });
 
 test('errorJoinMode: all', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'all',
 	}), {
-		instanceOf: ParserParsingJoinAllError
+		instanceOf: ParserParsingJoinAllError,
 	});
 
 	sortChildErrors(error);
@@ -107,7 +127,7 @@ test('errorJoinMode: all', async t => {
 });
 
 test('errorJoinMode: deepest', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'deepest',
 	}), {
 		instanceOf: ParserParsingJoinDeepestError,
@@ -142,7 +162,7 @@ test('errorJoinMode: deepest', async t => {
 });
 
 test('errorJoinMode: furthest', async t => {
-	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringInputCompanion, {
+	const error = await t.throwsAsync(runParser(sampleParser, asyncIteratorFromString('1bbfinal_CC!'), stringParserInputCompanion, {
 		errorJoinMode: 'furthest',
 	}), {
 		instanceOf: ParserParsingJoinFurthestError,
@@ -162,15 +182,116 @@ test('errorJoinMode: furthest', async t => {
 	t.is(error1.position, 12);
 });
 
-test('throws on inputCompanion type mismatch', async t => {
+test('throws on parserInputCompanion type mismatch', async t => {
 	const anythingParser: Parser<any, any> = createArrayParser(createElementParser());
 
-	await runParser(anythingParser, asyncIteratorFromString('anything'), stringInputCompanion);
-	await runParser(anythingParser, 'anything', stringInputCompanion);
-	await runParser(anythingParser, Buffer.from('anything'), uint8ArrayInputCompanion);
-	await runParser(anythingParser, new Uint8Array([ 1, 2, 3 ]), uint8ArrayInputCompanion);
+	await runParser(anythingParser, asyncIteratorFromString('anything'), stringParserInputCompanion);
+	await runParser(anythingParser, 'anything', stringParserInputCompanion);
+	await runParser(anythingParser, Buffer.from('anything'), uint8ArrayParserInputCompanion);
+	await runParser(anythingParser, new Uint8Array([ 1, 2, 3 ]), uint8ArrayParserInputCompanion);
 
-	await t.throwsAsync(runParser(anythingParser, asyncIteratorFromString('anything'), uint8ArrayInputCompanion), {
+	await t.throwsAsync(runParser(anythingParser, asyncIteratorFromString('anything'), uint8ArrayParserInputCompanion), {
 		message: /input companion/,
 	});
 });
+
+test('thrown error has input reader state', async t => {
+	const error = await t.throwsAsync(
+		runParser(
+			createTupleParser([
+				createExactSequenceNaiveParser('foo'),
+				createExactSequenceNaiveParser('bar'),
+			]),
+			(async function * () {
+				yield 'foo';
+				yield 'qux';
+				yield 'bar';
+			})(),
+			stringParserInputCompanion,
+		),
+		{
+			instanceOf: ParserError,
+		},
+	);
+
+	t.is(error.position, 4);
+
+	invariant(error.inputReaderSate, 'error.inputReaderSate');
+
+	const {
+		consumedBufferedSequences,
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+		position,
+		...inputReaderStateRest
+	} = error.inputReaderSate;
+
+	t.is(position, 4);
+	t.deepEqual(inputReaderStateRest, {});
+
+	const unbufferedSequencesArray = [];
+
+	if (unbufferedSequences) {
+		for await (const sequence of toAsyncIterable(unbufferedSequences)) {
+			unbufferedSequencesArray.push(sequence);
+		}
+	}
+
+	t.deepEqual(consumedBufferedSequences, [ 'q' ]);
+	t.deepEqual(unconsumedBufferedSequences, [ 'ux' ]);
+	t.deepEqual(unbufferedSequencesArray, [ 'bar' ]);
+});
+
+test('runParser throws with remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const error = await t.throwsAsync(() => runParser(parser, 'foobar', stringParserInputCompanion), {
+		instanceOf: ParserUnexpectedRemainingInputError,
+		message: /remaining input/,
+	});
+
+	t.is(error.position, 3);
+
+	const {
+		position,
+		consumedBufferedSequences,
+		unconsumedBufferedSequences,
+		unbufferedSequences,
+		...inputReaderStateRest
+	} = error.inputReaderSate!;
+
+	t.deepEqual(inputReaderStateRest, {});
+	t.is(position, 3);
+	t.deepEqual(consumedBufferedSequences, [ 'foo' ]);
+	t.deepEqual(unconsumedBufferedSequences, [ 'bar' ]);
+	t.truthy(unbufferedSequences);
+});
+
+test('runParser does not throw without remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const output = await runParser(parser, 'foo', stringParserInputCompanion);
+
+	t.deepEqual(output, 'foo');
+});
+
+test('runParserWithRemainingInput with remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const {
+		output,
+		remainingInput,
+		position,
+		...resultRest
+	} = await runParserWithRemainingInput(parser, 'foobar', stringParserInputCompanion);
+
+	t.deepEqual(resultRest, {});
+	t.deepEqual(output, 'foo');
+	t.deepEqual(await stringFromAsyncIterable(remainingInput!), 'bar');
+	t.is(position, 3);
+});
+
+test('runParserWithRemainingInput without remaining input', async t => {
+	const parser: Parser<string, string> = createExactSequenceNaiveParser('foo');
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'foo', stringParserInputCompanion);
+
+	t.deepEqual(output, 'foo');
+	t.is(remainingInput, undefined);
+});

package/src/parser.test.ts.md

@@ -8,32 +8,32 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    `ParserParsingJoinNoneError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinNoneError: No union child parser succeeded.␊
         at [LOCATIONS]`
 
 ## errorJoinMode: all
 
 > Snapshot 1
 
-    `ParserParsingJoinAllError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinAllError: No union child parser succeeded.␊
     Child error stacks, indented:␊
-      ParserParsingInvariantError: (position: 10) Expected "3", got "C", at [LOCATIONS]␊
-      ParserParsingInvariantError: (position: 10) Expected "c", got "C", at [LOCATIONS]␊
-      ParserParsingJoinAllError: (position: 3) No disjunction child parser succeeded.␊
+      ParserParsingInvariantError: Expected "3", got "C", at [LOCATIONS]␊
+      ParserParsingInvariantError: Expected "c", got "C", at [LOCATIONS]␊
+      ParserParsingJoinAllError: No disjunction child parser succeeded.␊
       Child error stacks, indented:␊
-        ParserParsingJoinAllError: (position: 4) No union child parser succeeded.␊
+        ParserParsingJoinAllError: No union child parser succeeded.␊
         Child error stacks, indented:␊
-          ParserParsingInvariantError: (position: 4) Expected "1", got "f", at [LOCATIONS]␊
-          ParserParsingInvariantError: (position: 4) Expected "a", got "f", at [LOCATIONS]␊
-          ParserParsingInvariantError: (position: 4) Expected "A", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "1", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "a", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "A", got "f", at [LOCATIONS]␊
         End of child error stacks␊
             at [LOCATIONS]␊
-        ParserParsingInvariantError: (position: 4) Expected "2", got "f", at [LOCATIONS]␊
-        ParserParsingInvariantError: (position: 4) Expected "b", got "f", at [LOCATIONS]␊
-        ParserParsingInvariantError: (position: 4) Expected "B", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: Expected "2", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: Expected "b", got "f", at [LOCATIONS]␊
+        ParserParsingInvariantError: Expected "B", got "f", at [LOCATIONS]␊
       End of child error stacks␊
           at [LOCATIONS]␊
-      ParserParsingInvariantError: (position: 12) Expected "C", got "!", at [LOCATIONS]␊
+      ParserParsingInvariantError: Expected "C", got "!", at [LOCATIONS]␊
     End of child error stacks␊
         at [LOCATIONS]`
 
@@ -41,15 +41,15 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    `ParserParsingJoinDeepestError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinDeepestError: No union child parser succeeded.␊
     Deepest child error stacks, indented:␊
-      ParserParsingJoinDeepestError: (position: 3) No disjunction child parser succeeded.␊
+      ParserParsingJoinDeepestError: No disjunction child parser succeeded.␊
       Deepest child error stacks, indented:␊
-        ParserParsingJoinDeepestError: (position: 4) No union child parser succeeded.␊
+        ParserParsingJoinDeepestError: No union child parser succeeded.␊
         Deepest child error stacks, indented:␊
-          ParserParsingInvariantError: (position: 4) Expected "1", got "f", at [LOCATIONS]␊
-          ParserParsingInvariantError: (position: 4) Expected "a", got "f", at [LOCATIONS]␊
-          ParserParsingInvariantError: (position: 4) Expected "A", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "1", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "a", got "f", at [LOCATIONS]␊
+          ParserParsingInvariantError: Expected "A", got "f", at [LOCATIONS]␊
         End of deepest child error stacks␊
             at [LOCATIONS]␊
       End of deepest child error stacks␊
@@ -61,8 +61,8 @@ Generated by [AVA](https://avajs.dev).
 
 > Snapshot 1
 
-    `ParserParsingJoinFurthestError: (position: 12) No union child parser succeeded.␊
+    `ParserParsingJoinFurthestError: No union child parser succeeded.␊
     Furthest child error stacks, indented:␊
-      ParserParsingInvariantError: (position: 12) Expected "C", got "!", at [LOCATIONS]␊
+      ParserParsingInvariantError: Expected "C", got "!", at [LOCATIONS]␊
     End of furthest child error stacks␊
         at [LOCATIONS]`