@futpib/parser 1.0.6 → 1.0.8

package/src/bashUnparser.test.ts

@@ -0,0 +1,37 @@
+import { testProp } from '@fast-check/ava';
+import { arbitraryBashCommandList } from './arbitraryBash.js';
+import { bashScriptUnparser } from './bashUnparser.js';
+import { bashScriptParser } from './bashParser.js';
+import { runParser } from './parser.js';
+import { runUnparser } from './unparser.js';
+import { stringParserInputCompanion } from './parserInputCompanion.js';
+import { stringUnparserOutputCompanion } from './unparserOutputCompanion.js';
+
+const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+
+async function collectString(asyncIterable: AsyncIterable<string>): Promise<string> {
+	let result = '';
+	for await (const chunk of asyncIterable) {
+		result += chunk;
+	}
+
+	return result;
+}
+
+testProp(
+	'bash roundtrip',
+	[arbitraryBashCommandList],
+	async (t, command) => {
+		const source = await collectString(runUnparser(
+			bashScriptUnparser, command, stringUnparserOutputCompanion));
+
+		const reparsed = await runParser(
+			bashScriptParser, source, stringParserInputCompanion);
+
+		t.deepEqual(reparsed, command);
+	},
+	{
+		verbose: true,
+		seed,
+	},
+);

package/src/bashUnparser.ts

@@ -0,0 +1,211 @@
+import { type Unparser } from './unparser.js';
+import {
+	type BashWord,
+	type BashWordPart,
+	type BashSimpleCommand,
+	type BashSubshell,
+	type BashBraceGroup,
+	type BashCommandUnit,
+	type BashPipeline,
+	type BashCommandList,
+	type BashRedirect,
+	type BashAssignment,
+	type BashCommand,
+} from './bash.js';
+
+function isIdentChar(ch: string): boolean {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
+}
+
+function nextPartStartsWithIdentChar(parts: BashWordPart[], index: number): boolean {
+	const next = parts[index + 1];
+	if (next === undefined) {
+		return false;
+	}
+
+	if (next.type === 'literal') {
+		return next.value.length > 0 && isIdentChar(next.value[0]!);
+	}
+
+	return false;
+}
+
+function unparseWord(word: BashWord): string {
+	return word.parts.map((part, i) => unparseWordPartInContext(part, word.parts, i)).join('');
+}
+
+function unparseWordPartInContext(part: BashWordPart, parts: BashWordPart[], index: number): string {
+	return unparseWordPart(part);
+}
+
+function unparseWordPart(part: BashWordPart): string {
+	switch (part.type) {
+		case 'literal':
+			return escapeLiteral(part.value);
+
+		case 'singleQuoted':
+			return "'" + part.value + "'";
+
+		case 'doubleQuoted':
+			return '"' + part.parts.map(p => unparseDoubleQuotedPart(p)).join('') + '"';
+
+		case 'variable':
+			return '$' + part.name;
+
+		case 'variableBraced': {
+			let result = '${' + part.name;
+			if (part.operator !== undefined) {
+				result += part.operator;
+				if (part.operand !== undefined) {
+					result += unparseWord(part.operand);
+				}
+			}
+
+			result += '}';
+			return result;
+		}
+
+		case 'commandSubstitution':
+			return '$( ' + unparseCommand(part.command) + ' )';
+
+		case 'backtickSubstitution':
+			return '`' + unparseCommand(part.command) + '`';
+
+		case 'arithmeticExpansion':
+			return '$((' + part.expression + '))';
+
+		case 'processSubstitution':
+			return part.direction + '(' + unparseCommand(part.command) + ')';
+	}
+}
+
+function unparseDoubleQuotedPart(part: BashWordPart): string {
+	switch (part.type) {
+		case 'literal': {
+			let result = '';
+			for (const ch of part.value) {
+				if (ch === '\\' || ch === '$' || ch === '`' || ch === '"') {
+					result += '\\' + ch;
+				} else {
+					result += ch;
+				}
+			}
+
+			return result;
+		}
+
+		default:
+			return unparseWordPart(part);
+	}
+}
+
+function escapeLiteral(value: string): string {
+	let result = '';
+	for (const ch of value) {
+		if (' \t\n|&;<>()$`"\' \\'.includes(ch) || ch === '{' || ch === '}' || ch === '#') {
+			result += '\\' + ch;
+		} else {
+			result += ch;
+		}
+	}
+
+	return result;
+}
+
+function unparseRedirect(redirect: BashRedirect): string {
+	let result = '';
+	if (redirect.fd !== undefined) {
+		result += String(redirect.fd);
+	}
+
+	result += redirect.operator;
+	if ('type' in redirect.target && redirect.target.type === 'hereDoc') {
+		result += redirect.target.delimiter;
+	} else {
+		result += unparseWord(redirect.target as BashWord);
+	}
+
+	return result;
+}
+
+function unparseAssignment(assignment: BashAssignment): string {
+	let result = assignment.name + '=';
+	if (assignment.value !== undefined) {
+		result += unparseWord(assignment.value);
+	}
+
+	return result;
+}
+
+function unparseSimpleCommand(cmd: BashSimpleCommand): string {
+	const parts: string[] = [];
+
+	for (const assignment of cmd.assignments) {
+		parts.push(unparseAssignment(assignment));
+	}
+
+	if (cmd.name !== undefined) {
+		parts.push(unparseWord(cmd.name));
+	}
+
+	for (const arg of cmd.args) {
+		parts.push(unparseWord(arg));
+	}
+
+	const wordParts = parts.join(' ');
+	const redirectParts = cmd.redirects.map(r => unparseRedirect(r)).join(' ');
+
+	if (redirectParts) {
+		return wordParts ? wordParts + ' ' + redirectParts : redirectParts;
+	}
+
+	return wordParts;
+}
+
+function unparseCommandUnit(unit: BashCommandUnit): string {
+	switch (unit.type) {
+		case 'simple':
+			return unparseSimpleCommand(unit);
+
+		case 'subshell':
+			return '(' + unparseCommand(unit.body) + ')';
+
+		case 'braceGroup':
+			return '{ ' + unparseCommand(unit.body) + ' }';
+	}
+}
+
+function unparsePipeline(pipeline: BashPipeline): string {
+	let result = '';
+	if (pipeline.negated) {
+		result += '! ';
+	}
+
+	result += pipeline.commands.map(cmd => unparseCommandUnit(cmd)).join(' | ');
+	return result;
+}
+
+function unparseCommand(command: BashCommand): string {
+	return unparseCommandList(command);
+}
+
+function unparseCommandList(list: BashCommandList): string {
+	let result = '';
+	for (let i = 0; i < list.entries.length; i++) {
+		const entry = list.entries[i]!;
+		if (i > 0) {
+			result += ' ';
+		}
+
+		result += unparsePipeline(entry.pipeline);
+		if (entry.separator !== undefined) {
+			result += entry.separator;
+		}
+	}
+
+	return result;
+}
+
+export const bashScriptUnparser: Unparser<BashCommand, string> = async function * (command) {
+	yield unparseCommand(command);
+};

package/src/bsonParser.ts

@@ -6,10 +6,10 @@ import { createTupleParser } from './tupleParser.js';
 import { createSkipParser } from './skipParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
-import { createElementParser } from './elementParser.js';
 import { createExactElementParser } from './exactElementParser.js';
 import { createUnionParser } from './unionParser.js';
 import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 
 const createFixedLengthBufferParser = (length: number): Parser<Buffer, Uint8Array> => promiseCompose(createFixedLengthSequenceParser<Uint8Array>(length), sequence => Buffer.from(sequence));
 
@@ -17,16 +17,13 @@ const buffer1Parser = createFixedLengthBufferParser(1);
 const buffer4Parser = createFixedLengthBufferParser(4);
 const buffer8Parser = createFixedLengthBufferParser(8);
 
-const elementParser: Parser<number, Uint8Array> = createElementParser();
-
 const nullByteParser: Parser<number, Uint8Array> = createExactElementParser(0);
 
+const nonNullByteParser: Parser<number, Uint8Array> = createPredicateElementParser((byte: number) => byte !== 0);
+
 const cstringParser: Parser<string, Uint8Array> = promiseCompose(
 	createTerminatedArrayParser(
-		parserCreatorCompose(
-			() => elementParser,
-			(byte: number) => async parserContext => parserContext.invariant(byte, 'Expected non-null byte'),
-		)(),
+		nonNullByteParser,
 		nullByteParser,
 	),
 	([ sequence ]) => Buffer.from(sequence).toString('utf8'),

package/src/dalvikExecutableParser/stringSyntaxParser.ts

@@ -1,84 +1,37 @@
-import invariant from 'invariant';
 import { type Parser, setParserName } from '../parser.js';
-import { type ParserContext } from '../parserContext.js';
 import { promiseCompose } from '../promiseCompose.js';
 import { createSeparatedArrayParser } from '../separatedArrayParser.js';
 import { createExactSequenceParser } from '../exactSequenceParser.js';
 import { createUnionParser } from '../unionParser.js';
 import { createTupleParser } from '../tupleParser.js';
 import { createArrayParser } from '../arrayParser.js';
-
-export const smaliSimpleNameParser: Parser<string, string> = async (parserContext: ParserContext<string, string>) => {
-	const characters: string[] = [];
-
-	while (true) {
-		const character = await parserContext.peek(0);
-
-		parserContext.invariant(character !== undefined, 'Unexpected end of input');
-
-		invariant(character !== undefined, 'Unexpected end of input');
-
-		if (
-			(
-				character >= 'a' && character <= 'z'
-			)
-			|| (
-				character >= 'A' && character <= 'Z'
-			)
-			|| (
-				character >= '0' && character <= '9'
-			)
-			|| (
-				character === ' '
-			)
-			|| (
-				character === '$'
-			)
-			|| (
-				character === '-'
-			)
-				|| (
-					character === '_'
-				)
-				|| (
-					character === '\u00A0'
-				)
-				|| (
-					character >= '\u00A1' && character <= '\u1FFF'
-				)
-				|| (
-					character >= '\u2000' && character <= '\u200A'
-				)
-				|| (
-					character >= '\u2010' && character <= '\u2027'
-				)
-				|| (
-					character === '\u202F'
-				)
-				|| (
-					character >= '\u2030' && character <= '\uD7FF'
-				)
-				|| (
-					character >= '\uE000' && character <= '\uFFEF'
-				)
-				|| (
-					character >= '\uD800' && character <= '\uDBFF'
-				)
-		) {
-			parserContext.skip(1);
-
-			characters.push(character);
-
-			continue;
-		}
-
-		parserContext.invariant(characters.length > 0, 'Expected at least one character');
-
-		break;
-	}
-
-	return characters.join('');
-};
+import { createNonEmptyArrayParser } from '../nonEmptyArrayParser.js';
+import { createPredicateElementParser } from '../predicateElementParser.js';
+
+function isSmaliSimpleNameChar(character: string): boolean {
+	return (
+		(character >= 'a' && character <= 'z')
+		|| (character >= 'A' && character <= 'Z')
+		|| (character >= '0' && character <= '9')
+		|| character === ' '
+		|| character === '$'
+		|| character === '-'
+		|| character === '_'
+		|| character === '\u00A0'
+		|| (character >= '\u00A1' && character <= '\u1FFF')
+		|| (character >= '\u2000' && character <= '\u200A')
+		|| (character >= '\u2010' && character <= '\u2027')
+		|| character === '\u202F'
+		|| (character >= '\u2030' && character <= '\uD7FF')
+		|| (character >= '\uE000' && character <= '\uFFEF')
+		|| (character >= '\uD800' && character <= '\uDBFF')
+	);
+}
+
+export const smaliSimpleNameParser: Parser<string, string> = promiseCompose(
+	createNonEmptyArrayParser(createPredicateElementParser(isSmaliSimpleNameChar)),
+	characters => characters.join(''),
+);
 
 setParserName(smaliSimpleNameParser, 'smaliSimpleNameParser');
 

package/src/dalvikExecutableParser.ts

@@ -13,6 +13,7 @@ import { createTupleParser } from './tupleParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
 import { createSkipToParser } from './skipToParser.js';
 import { createLookaheadParser } from './lookaheadParser.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 import {
 	getIsoTypedNumberArray,
 	type IndexIntoFieldIds,
@@ -843,16 +844,9 @@ type DalvikExecutableTaggedEncodedValue =
 	| { type: 'boolean'; value: boolean };
 
 const createByteWith5LeastSignificantBitsEqualParser = (leastSignificant5: number): Parser<number, Uint8Array> => {
-	const byteWith5LeastSignificantBitsEqualParser: Parser<number, Uint8Array> = async parserContext => {
-		const byte = await parserContext.read(0);
-		parserContext.invariant(
-			(byte & 0b0001_1111) === leastSignificant5,
-			'Expected byte with 5 least significant bits equal to %s, but got %s',
-			leastSignificant5.toString(2).padStart(8, '0'),
-			byte.toString(2).padStart(8, '0'),
-		);
-		return byte;
-	};
+	const byteWith5LeastSignificantBitsEqualParser: Parser<number, Uint8Array> = createPredicateElementParser(
+		(byte: number) => (byte & 0b0001_1111) === leastSignificant5,
+	);
 
 	setParserName(byteWith5LeastSignificantBitsEqualParser, `createByteWith5LeastSignificantBitsEqualParser(${leastSignificant5.toString(2).padStart(5, '0')})`);
 

package/src/hasExecutable.ts

@@ -1,7 +1,7 @@
 import { execa } from 'execa';
 
 export async function hasExecutable(executable: string) {
-	const hasExecutable = execa(executable).catch(() => false).then(() => true);
+	const hasExecutable = await execa(executable).then(() => true).catch(() => false);
 
 	if (!hasExecutable) {
 		console.warn('Executable %o not found', executable);

package/src/index.ts

@@ -96,6 +96,10 @@ export {
 	createElementParser,
 } from './elementParser.js';
 
+export {
+	createPredicateElementParser,
+} from './predicateElementParser.js';
+
 export {
 	createTerminatedArrayParser,
 } from './terminatedArrayParser.js';

package/src/jsonParser.ts

@@ -11,8 +11,7 @@ import { createDisjunctionParser } from './disjunctionParser.js';
 import { createTerminatedArrayParser } from './terminatedArrayParser.js';
 import { createArrayParser } from './arrayParser.js';
 import { createParserAccessorParser } from './parserAccessorParser.js';
-import { createElementParser } from './elementParser.js';
-import { parserCreatorCompose } from './parserCreatorCompose.js';
+import { createPredicateElementParser } from './predicateElementParser.js';
 import { createSeparatedArrayParser } from './separatedArrayParser.js';
 import { createRegExpParser } from './regexpParser.js';
 
@@ -52,17 +51,9 @@ const jsonStringEscapeSequenceParser: Parser<string, string> = createUnionParser
 	jsonUnicodeEscapeSequenceParser,
 ]);
 
-const elementParser: Parser<string, string> = createElementParser();
-
 const jsonStringCharacterParser: Parser<string, string> = createDisjunctionParser([
 	jsonStringEscapeSequenceParser,
-	parserCreatorCompose(
-		() => elementParser,
-		character => async parserContext => {
-			parserContext.invariant(character !== '"', 'Unexpected """');
-			return character;
-		},
-	)(),
+	createPredicateElementParser((character: string) => character !== '"'),
 ]);
 
 export const jsonStringParser: Parser<string, string> = promiseCompose(

package/src/predicateElementParser.ts

@@ -0,0 +1,22 @@
+import { setParserName, type Parser } from './parser.js';
+import { type DeriveSequenceElement } from './sequence.js';
+
+export const createPredicateElementParser = <Sequence, Element = DeriveSequenceElement<Sequence>>(
+	predicate: (element: Element) => boolean,
+): Parser<Element, Sequence, Element> => {
+	const predicateElementParser: Parser<Element, Sequence, Element> = async parserContext => {
+		const element = await parserContext.read(0);
+
+		parserContext.invariant(
+			predicate(element),
+			'Element does not match predicate: %s',
+			element,
+		);
+
+		return element;
+	};
+
+	setParserName(predicateElementParser, `createPredicateElementParser(${predicate.name || 'anonymous'})`);
+
+	return predicateElementParser;
+};

package/src/regularExpression.ts

@@ -9,6 +9,16 @@ export type CharacterSet =
 
 export type RepeatBounds = number | { min: number; max?: number } | { min?: number; max: number };
 
+export enum AssertionSign {
+	POSITIVE = 0,
+	NEGATIVE = 1,
+}
+
+export enum AssertionDir {
+	AHEAD = 0,
+	BEHIND = 1,
+}
+
 export type RegularExpression =
 	| { type: 'epsilon' }
 	| { type: 'literal'; charset: CharacterSet }
@@ -19,6 +29,6 @@ export type 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: 'assertion'; direction: AssertionDir; sign: AssertionSign; inner: RegularExpression; outer: RegularExpression }
 	| { type: 'start-anchor'; left: RegularExpression; right: RegularExpression }
 	| { type: 'end-anchor'; left: RegularExpression; right: RegularExpression };

package/src/regularExpressionParser.test.ts

@@ -9,7 +9,7 @@ import { parseRegExpString } from '../node_modules/@gruhn/regex-utils/dist/regex
 import { runParser } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { arbitrarilySlicedAsyncIterator } from './arbitrarilySlicedAsyncInterator.js';
-import type { RegularExpression, CharacterSet } from './regularExpression.js';
+import { AssertionDir, AssertionSign, type RegularExpression, type CharacterSet } from './regularExpression.js';
 
 // Normalize AST for comparison - removes hashes from CharSets and normalizes structure
 function normalizeCharacterSet(charset: CharacterSet): CharacterSet {
@@ -47,8 +47,8 @@ function normalizeRegularExpression(ast: RegularExpression): RegularExpression {
 				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 'assertion':
+			return { type: 'assertion', direction: ast.direction, sign: ast.sign, inner: normalizeRegularExpression(ast.inner), outer: normalizeRegularExpression(ast.outer) };
 		case 'start-anchor':
 			return { type: 'start-anchor', left: normalizeRegularExpression(ast.left), right: normalizeRegularExpression(ast.right) };
 		case 'end-anchor':