@futpib/parser 1.0.1 → 1.0.2

package/src/sliceBoundedParser.test.ts

@@ -3,8 +3,19 @@ import { createArrayParser } from './arrayParser.js';
 import { createElementParser } from './elementParser.js';
 import { createTupleParser } from './tupleParser.js';
 import { createSliceBoundedParser } from './sliceBoundedParser.js';
-import { runParser } from './parser.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;
+}
 
 const anythingParser = createArrayParser(createElementParser<string>());
 
@@ -26,3 +37,34 @@ test('sliceBoundedParser', async t => {
 		'a',
 	]);
 });
+
+test('sliceBoundedParser mustConsumeAll: true fail to cosume all', async t => {
+	const parser = createTupleParser([
+		createElementParser<string>(),
+		createSliceBoundedParser(createArrayParser(createExactElementParser('b' as string)), 2),
+		createElementParser(),
+	]);
+
+	await t.throwsAsync(() => runParser(parser, 'abcd', stringParserInputCompanion), {
+		message: /child parser must consume all input in the slice/,
+	});
+});
+
+test('sliceBoundedParser mustConsumeAll: false', async t => {
+	const parser = createTupleParser([
+		createElementParser<string>(),
+		createSliceBoundedParser(createArrayParser(createExactElementParser('b' as string)), 2, false),
+		createElementParser(),
+	]);
+
+	const { output, remainingInput } = await runParserWithRemainingInput(parser, 'abcd', stringParserInputCompanion);
+
+	t.deepEqual(output, [
+		'a',
+		[
+			'b',
+		],
+		'c',
+	]);
+	t.deepEqual(await stringFromAsyncIterable(remainingInput!), 'd');
+});

package/src/sliceBoundedParser.ts

@@ -3,14 +3,30 @@ import { getParserName, type Parser, setParserName } from './parser.js';
 export const createSliceBoundedParser = <Output, Sequence>(
 	childParser: Parser<Output, Sequence>,
 	sliceEnd: number,
+	mustConsumeAll: boolean = true,
 ): Parser<Output, Sequence> => {
 	const sliceBoundedParser: typeof childParser = async parserContext => {
+		const absoluteSliceEnd = parserContext.position + sliceEnd;
+
 		const childParserContext = parserContext.lookahead({
-			sliceEnd: parserContext.position + sliceEnd,
+			sliceEnd: absoluteSliceEnd,
 		});
 
 		try {
 			const value = await childParser(childParserContext);
+
+			childParserContext.invariant(
+				(
+					!mustConsumeAll
+						|| 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,
+				absoluteSliceEnd,
+				childParserContext.position - parserContext.position,
+				childParserContext.position,
+			);
+
 			childParserContext.unlookahead();
 			return value;
 		} finally {
@@ -23,6 +39,8 @@ export const createSliceBoundedParser = <Output, Sequence>(
 		getParserName(childParser, 'anonymousSliceBoundedChild'),
 		',',
 		sliceEnd,
+		',',
+		mustConsumeAll,
 		')',
 	].join(''));
 

package/src/smali.ts

@@ -0,0 +1,24 @@
+import fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { temporaryFile } from 'tempy';
+
+export async function smaliClass(smaliStream: AsyncIterable<string>) {
+	const inputFilePath = temporaryFile();
+	const outputFilePath = temporaryFile();
+
+	await fs.writeFile(inputFilePath, smaliStream);
+
+	await execa('smali', [
+		'assemble',
+		'--output', outputFilePath,
+		inputFilePath,
+	]);
+
+	await fs.unlink(inputFilePath);
+
+	const dex = await fs.readFile(outputFilePath);
+
+	await fs.unlink(outputFilePath);
+
+	return dex;
+}

package/src/smaliParser.test.ts

@@ -0,0 +1,132 @@
+import test from 'ava';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { getParserName, Parser, runParser } from './parser.js';
+import { fetchCid } from './fetchCid.js';
+import { smaliAnnotationParser, smaliCodeParameterParser, smaliFieldParser, smaliParser } from './smaliParser.js';
+import { hasExecutable } from './hasExecutable.js';
+import { baksmaliClass } from './backsmali.js';
+
+const hasBaksmaliPromise = hasExecutable('baksmali');
+
+function stringParserTest<Output>(parser: Parser<Output, string>, examples: [ string, Output ][]) {
+	const parserName = getParserName(parser);
+
+	for (const [ input, expected ] of examples) {
+		test(parserName + ' ' + JSON.stringify(input), async t => {
+			const actual = await runParser(parser, input, stringParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			t.deepEqual(actual, expected as any);
+		});
+	}
+}
+
+stringParserTest(smaliCodeParameterParser, [
+	[
+		'    .param p1\n',
+		{
+			index: 1,
+			prefix: 'p',
+		},
+	],
+	[
+		'    .param p1, "savedInstanceState"    # Landroid/os/Bundle;\n',
+		{
+			index: 1,
+			prefix: 'p',
+		},
+	],
+]);
+
+stringParserTest(smaliFieldParser, [
+	[
+		'.field private barcodeScannerView:Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;\n',
+		{
+			accessFlags: {
+				abstract: false,
+				annotation: false,
+				bridge: false,
+				constructor: false,
+				declaredSynchronized: false,
+				enum: false,
+				final: false,
+				interface: false,
+				native: false,
+				private: true,
+				protected: false,
+				public: false,
+				static: false,
+				strict: false,
+				synchronized: false,
+				synthetic: false,
+				transient: false,
+				varargs: false,
+				volatile: false,
+			},
+			field: {
+				class: 'FILLED_LATER',
+				name: 'barcodeScannerView',
+				type: 'Lcom/journeyapps/barcodescanner/DecoratedBarcodeView;',
+			},
+		},
+	],
+]);
+
+stringParserTest(smaliAnnotationParser, [
+	[
+		`    .annotation system Ldalvik/annotation/Signature;
+                value = {
+                    "<T:",
+                    "Landroid/view/View;",
+                    ">(I)TT;"
+                }
+            .end annotation
+`,
+		{
+			type: 'Ldalvik/annotation/Signature;',
+			value: [
+				'<T:',
+				'Landroid/view/View;',
+				'>(I)TT;',
+			],
+		},
+	],
+]);
+
+for (const [ dexCid, smaliFilePath, shouldSnapshot ] of [
+	[ 'bafkreibb4gsprc3fvmnyqx6obswvm7e7wngnfj64gz65ey72r7xgyzymt4', 'pl/czak/minimal/MainActivity', true ],
+	[ 'bafybeiebe27ylo53trgitu6fqfbmba43c4ivxj3nt4kumsilkucpbdxtqq', 'd/m', true ],
+	// [ 'bafybeibbupm7uzhuq4pa674rb2amxsenbdaoijigmaf4onaodaql4mh7yy', 'com/journeyapps/barcodescanner/CaptureActivity', true ],
+	// [ 'bafybeicb3qajmwy6li7hche2nkucvytaxcyxhwhphmi73tgydjzmyoqoda', false ],
+] as const) {
+	test.serial(
+		'smali from dex ' + dexCid + ' ' + smaliFilePath,
+		async t => {
+			const hasBaksmali = await hasBaksmaliPromise;
+
+			if (!hasBaksmali) {
+				t.pass('skipping test because baksmali is not available');
+
+				return;
+			}
+
+			const dexStream = await fetchCid(dexCid);
+
+			const smali = await baksmaliClass(dexStream, smaliFilePath);
+
+			const actual = await runParser(smaliParser, smali, stringParserInputCompanion, {
+				errorJoinMode: 'all',
+			});
+
+			// console.dir(actual, { depth: null });
+
+			if (shouldSnapshot) {
+				t.snapshot(actual);
+			} else {
+				//console.dir(actual, { depth: null });
+				t.pass();
+			}
+		},
+	);
+}