@futpib/parser 1.0.2 → 1.0.4

package/src/separatedArrayParser.ts

@@ -1,5 +1,5 @@
 import { getParserName, type Parser, setParserName } from './parser.js';
-import { ParserParsingFailedError } from './parserError.js';
+import { isParserParsingFailedError } from './parserError.js';
 import { promiseCompose } from './promiseCompose.js';
 import { createTupleParser } from './tupleParser.js';
 
@@ -34,7 +34,7 @@ export const createSeparatedArrayParser = <ElementOutput, Sequence>(
 				elements.push(element);
 				elementParserContext.unlookahead();
 			} catch (error) {
-				if (error instanceof ParserParsingFailedError) {
+				if (isParserParsingFailedError(error)) {
 					break;
 				}
 
@@ -43,7 +43,7 @@ export const createSeparatedArrayParser = <ElementOutput, Sequence>(
 				elementParserContext.dispose();
 			}
 
-			parser = separatorThenElementParser
+			parser = separatorThenElementParser;
 		}
 
 		return elements;

package/src/separatedNonEmptyArrayParser.test.ts

@@ -0,0 +1,117 @@
+import test from 'ava';
+import { testProp, fc } from '@fast-check/ava';
+import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { type Parser, runParser, runParserWithRemainingInput } from './parser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { createExactSequenceParser } from './exactSequenceParser.js';
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
+
+test('empty input throws error', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	await t.throwsAsync(async () => runParser(parser, '', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('single element without separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'element', stringParserInputCompanion);
+	t.deepEqual(result, [ 'element' ]);
+});
+
+test('two elements with separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'element,element', stringParserInputCompanion);
+	t.deepEqual(result, [ 'element', 'element' ]);
+});
+
+test('multiple elements with separator matches', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('a'),
+		createExactSequenceParser(','),
+	);
+
+	const result = await runParser(parser, 'a,a,a,a', stringParserInputCompanion);
+	t.deepEqual(result, [ 'a', 'a', 'a', 'a' ]);
+});
+
+test('does not consume trailing separator', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'element,element,', stringParserInputCompanion);
+	t.deepEqual(output, [ 'element', 'element' ]);
+	t.is(await stringFromAsyncIterable(remainingInput!), ',');
+});
+
+test('does not loop forever with a child parser that does not consume anything', async t => {
+	const parser: Parser<undefined[], string> = createSeparatedNonEmptyArrayParser(
+		async () => undefined,
+		() => undefined,
+	);
+
+	await t.throwsAsync(async () => runParser(parser, 'foo', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+test('partial match throws error', async t => {
+	const parser: Parser<string[], string> = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser(','),
+	);
+
+	await t.throwsAsync(async () => runParser(parser, 'elem', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});
+
+testProp(
+	'separatedNonEmptyArray with at least one element',
+	[
+		fc.array(fc.constant('element'), { minLength: 1 }),
+	],
+	async (t, elements) => {
+		const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(
+			createExactSequenceParser('element'),
+			createExactSequenceParser('separator'),
+		);
+
+		const actual = await runParser(separatedNonEmptyArrayParser, elements.join('separator'), stringParserInputCompanion);
+		const expected = elements;
+
+		t.deepEqual(actual, expected);
+	},
+	{
+		verbose: true,
+	},
+);
+
+test('separatedNonEmptyArray throws on empty array', async t => {
+	const separatedNonEmptyArrayParser = createSeparatedNonEmptyArrayParser(
+		createExactSequenceParser('element'),
+		createExactSequenceParser('separator'),
+	);
+
+	await t.throwsAsync(async () => runParser(separatedNonEmptyArrayParser, '', stringParserInputCompanion), {
+		any: true,
+		message: /Expected .* to match at least once/,
+	});
+});

package/src/separatedNonEmptyArrayParser.ts

@@ -0,0 +1,61 @@
+import { getParserName, type Parser, setParserName } from './parser.js';
+import { isParserParsingFailedError, ParserParsingFailedError } from './parserError.js';
+import { promiseCompose } from './promiseCompose.js';
+import { createTupleParser } from './tupleParser.js';
+
+export const createSeparatedNonEmptyArrayParser = <ElementOutput, Sequence>(
+	elementParser: Parser<ElementOutput, Sequence>,
+	separatorParser: Parser<unknown, Sequence>,
+): Parser<ElementOutput[], Sequence> => {
+	const separatorThenElementParser: Parser<ElementOutput, Sequence> = promiseCompose(
+		createTupleParser([
+			separatorParser,
+			elementParser,
+		]),
+		([ , element ]) => element,
+	);
+
+	const separatedNonEmptyArrayParser: Parser<ElementOutput[], Sequence> = async parserContext => {
+		let parser = elementParser;
+
+		const elements: ElementOutput[] = [];
+
+		while (true) {
+			const elementParserContext = parserContext.lookahead();
+			const initialPosition = elementParserContext.position;
+
+			try {
+				const element = await parser(elementParserContext);
+
+				if (elementParserContext.position === initialPosition) {
+					break;
+				}
+
+				elements.push(element);
+				elementParserContext.unlookahead();
+			} catch (error) {
+				if (isParserParsingFailedError(error)) {
+					break;
+				}
+
+				throw error;
+			} finally {
+				elementParserContext.dispose();
+			}
+
+			parser = separatorThenElementParser;
+		}
+
+		parserContext.invariant(
+			elements.length > 0,
+			'Expected elementParser (%s) to match at least once',
+			getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild'),
+		);
+
+		return elements;
+	};
+
+	setParserName(separatedNonEmptyArrayParser, getParserName(elementParser, 'anonymousSeparatedNonEmptyArrayChild') + '+');
+
+	return separatedNonEmptyArrayParser;
+};

package/src/sequenceBuffer.test.ts

@@ -33,7 +33,7 @@ test('sequenceBuffer', t => {
 
 	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
 		consumedBufferedSequences: [],
-		unconsumedBufferedSequences: ['abc'],
+		unconsumedBufferedSequences: [ 'abc' ],
 	});
 
 	sequenceBuffer.push('def');
@@ -50,7 +50,7 @@ test('sequenceBuffer', t => {
 
 	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
 		consumedBufferedSequences: [],
-		unconsumedBufferedSequences: ['abc', 'def'],
+		unconsumedBufferedSequences: [ 'abc', 'def' ],
 	});
 
 	sequenceBuffer.push('');
@@ -62,7 +62,7 @@ test('sequenceBuffer', t => {
 
 	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
 		consumedBufferedSequences: [],
-		unconsumedBufferedSequences: ['abc', 'def', ''],
+		unconsumedBufferedSequences: [ 'abc', 'def', '' ],
 	});
 
 	sequenceBuffer.skip(1);
@@ -73,8 +73,8 @@ test('sequenceBuffer', t => {
 	t.is(sequenceBuffer.peek(5), undefined);
 
 	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
-		consumedBufferedSequences: ['a'],
-		unconsumedBufferedSequences: ['bc', 'def', ''],
+		consumedBufferedSequences: [ 'a' ],
+		unconsumedBufferedSequences: [ 'bc', 'def', '' ],
 	});
 
 	sequenceBuffer.skip(3);
@@ -84,8 +84,8 @@ test('sequenceBuffer', t => {
 	t.is(sequenceBuffer.peek(2), undefined);
 
 	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
-		consumedBufferedSequences: ['d'],
-		unconsumedBufferedSequences: ['ef', ''],
+		consumedBufferedSequences: [ 'd' ],
+		unconsumedBufferedSequences: [ 'ef', '' ],
 	});
 
 	sequenceBuffer.push('gh');
@@ -101,8 +101,8 @@ test('sequenceBuffer', t => {
 	t.is(sequenceBuffer.peekSequence(1, 5), undefined, 'fgh?');
 
 	t.deepEqual(sequenceBuffer.toSequenceBufferState(), {
-		consumedBufferedSequences: ['d'],
-		unconsumedBufferedSequences: ['ef', '', 'gh'],
+		consumedBufferedSequences: [ 'd' ],
+		unconsumedBufferedSequences: [ 'ef', '', 'gh' ],
 	});
 });
 

package/src/sequenceBuffer.ts

@@ -88,7 +88,7 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 					sequence,
 					Math.max(0, startIndex),
 					Math.min(sequenceLength, endIndex),
-				)
+				);
 				sequences.push(subsequence);
 			}
 
@@ -120,7 +120,7 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		if (this._indexInFirstSequence === 0) {
 			return {
 				consumedBufferedSequences: [],
-				unconsumedBufferedSequences: this._sequences.slice(),
+				unconsumedBufferedSequences: [ ...this._sequences ],
 			};
 		}
 
@@ -133,11 +133,11 @@ export class SequenceBufferImplementation<Sequence, Element> implements Sequence
 		const unconsumedFirstSequenceLength = this._parserInputCompanion.length(unconsumedFirstSequence);
 
 		return {
-			consumedBufferedSequences: [consumedFirstSequence],
+			consumedBufferedSequences: [ consumedFirstSequence ],
 			unconsumedBufferedSequences: (
 				unconsumedFirstSequenceLength === 0
 					? this._sequences.slice(1)
-					: [unconsumedFirstSequence, ...this._sequences.slice(1)]
+					: [ unconsumedFirstSequence, ...this._sequences.slice(1) ]
 			),
 		};
 	}

package/src/sequenceTerminatedSequenceParser.test.ts

@@ -1,6 +1,6 @@
 import * as fc from 'fast-check';
 import { testProp } from '@fast-check/ava';
-import { Parser, runParser } from './parser.js';
+import { type Parser, runParser } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createSequenceTerminatedSequenceParser } from './sequenceTerminatedSequenceParser.js';
 
@@ -21,12 +21,10 @@ testProp.serial(
 				string,
 				terminator: string.slice(-terminatorLength),
 			}))
-			.filter(({ string, terminator }) => string.split(terminator).length === 2)
+			.filter(({ string, terminator }) => string.split(terminator).length === 2),
 	],
 	async (t, { string, terminator }) => {
-		const sequenceTerminatedSequenceParser = createSequenceTerminatedSequenceParser<string>(
-			terminator,
-		);
+		const sequenceTerminatedSequenceParser = createSequenceTerminatedSequenceParser<string>(terminator);
 
 		const createTestWrapperParser = (innerParser: typeof sequenceTerminatedSequenceParser): Parser<{
 			string: string;

package/src/sequenceTerminatedSequenceParser.ts

@@ -1,6 +1,6 @@
-import { inspect } from "./inspect.js";
-import { Parser, setParserName } from "./parser.js";
-import { DeriveSequenceElement } from "./sequence.js";
+import { inspect } from './inspect.js';
+import { type Parser, setParserName } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
 
 function clamp(x: number, min: number, max: number) {
 	return Math.max(min, Math.min(x, max));
@@ -41,7 +41,7 @@ export const createSequenceTerminatedSequenceParser = <Sequence, Element = Deriv
 			const terminatorIndex = parserContext.indexOfSubsequence(sequence, terminatorSequence);
 
 			if (terminatorIndex === -1) {
-				window = window * 2;
+				window *= 2;
 
 				continue;
 			}

package/src/sequenceUnparser.ts

@@ -1,4 +1,4 @@
-import { Unparser } from "./unparser.js";
+import { type Unparser } from './unparser.js';
 
 export const createSequenceUnparser = <Sequence>(): Unparser<Sequence, Sequence> => {
 	const sequenceUnparser: Unparser<Sequence, Sequence> = async function * (input) {
@@ -6,4 +6,4 @@ export const createSequenceUnparser = <Sequence>(): Unparser<Sequence, Sequence>
 	};
 
 	return sequenceUnparser;
-}
+};

package/src/skipToParser.ts

@@ -1,8 +1,8 @@
-import { Parser, setParserName } from "./parser.js";
+import { type Parser, setParserName } from './parser.js';
 import { parserImplementationInvariant } from './parserImplementationInvariant.js';
 
 export const createSkipToParser = (offset: number): Parser<void, Uint8Array> => {
-	const skipToParser: Parser<void, Uint8Array> = (parserContext) => {
+	const skipToParser: Parser<void, Uint8Array> = parserContext => {
 		const length = offset - parserContext.position;
 
 		parserImplementationInvariant(length >= 0, 'Skip length must be positive, got %s (position: %s)', length, parserContext.position);

package/src/sliceBoundedParser.test.ts

@@ -6,16 +6,7 @@ import { createSliceBoundedParser } from './sliceBoundedParser.js';
 import { runParser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { createExactElementParser } from './exactElementParser.js';
-
-async function stringFromAsyncIterable(asyncIterable: AsyncIterable<string>) {
-	let string = '';
-
-	for await (const chunk of asyncIterable) {
-		string += chunk;
-	}
-
-	return string;
-}
+import { stringFromAsyncIterable } from './stringFromAsyncIterable.js';
 
 const anythingParser = createArrayParser(createElementParser<string>());
 
@@ -45,7 +36,8 @@ test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async t => {
 		createElementParser(),
 	]);
 
-	await t.throwsAsync(() => runParser(parser, 'abcd', stringParserInputCompanion), {
+	await t.throwsAsync(async () => runParser(parser, 'abcd', stringParserInputCompanion), {
+		any: true,
 		message: /child parser must consume all input in the slice/,
 	});
 });
@@ -66,5 +58,5 @@ test('sliceBoundedParser mustConsumeAll: false', async t => {
 		],
 		'c',
 	]);
-	t.deepEqual(await stringFromAsyncIterable(remainingInput!), 'd');
+	t.is(await stringFromAsyncIterable(remainingInput!), 'd');
 });

package/src/sliceBoundedParser.ts

@@ -3,7 +3,7 @@ import { getParserName, type Parser, setParserName } from './parser.js';
 export const createSliceBoundedParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
 	sliceEnd: number,
-	mustConsumeAll: boolean = true,
+	mustConsumeAll = true,
 ): Parser<Output, Sequence> => {
 	const sliceBoundedParser: typeof childParser = async parserContext => {
 		const absoluteSliceEnd = parserContext.position + sliceEnd;
@@ -18,7 +18,7 @@ export const createSliceBoundedParser = <Output, Sequence>(
 			childParserContext.invariant(
 				(
 					!mustConsumeAll
-						|| childParserContext.position === absoluteSliceEnd
+					|| childParserContext.position === absoluteSliceEnd
 				),
 				'child parser must consume all input in the slice (%s in total, up to position %s), instead consumed %s up to position %s',
 				sliceEnd,

package/src/smali.ts

@@ -2,18 +2,23 @@ import fs from 'node:fs/promises';
 import { execa } from 'execa';
 import { temporaryFile } from 'tempy';
 
-export async function smaliClass(smaliStream: AsyncIterable<string>) {
+export async function smaliClass(smaliStream: string | AsyncIterable<string>): Promise<Uint8Array> {
 	const inputFilePath = temporaryFile();
 	const outputFilePath = temporaryFile();
 
 	await fs.writeFile(inputFilePath, smaliStream);
 
-	await execa('smali', [
+	const smaliResult = await execa('smali', [
 		'assemble',
-		'--output', outputFilePath,
+		'--output',
+		outputFilePath,
 		inputFilePath,
 	]);
 
+	if (smaliResult.stderr) {
+		throw new Error(`smali error: ${smaliResult.stderr}`);
+	}
+
 	await fs.unlink(inputFilePath);
 
 	const dex = await fs.readFile(outputFilePath);