@futpib/parser 1.0.4 → 1.0.6

package/src/bashParser.ts

@@ -10,6 +10,7 @@ import { createOptionalParser } from './optionalParser.js';
 import { createRegExpParser } from './regexpParser.js';
 import { createNonEmptyArrayParser } from './nonEmptyArrayParser.js';
 import { createSeparatedNonEmptyArrayParser } from './separatedNonEmptyArrayParser.js';
+import { createObjectParser } from './objectParser.js';
 import {
 	type BashWord,
 	type BashWordPart,
@@ -17,8 +18,11 @@ import {
 	type BashWordPartSingleQuoted,
 	type BashWordPartDoubleQuoted,
 	type BashWordPartVariable,
+	type BashWordPartVariableBraced,
 	type BashWordPartCommandSubstitution,
 	type BashWordPartBacktickSubstitution,
+	type BashWordPartArithmeticExpansion,
+	type BashWordPartProcessSubstitution,
 	type BashSimpleCommand,
 	type BashSubshell,
 	type BashBraceGroup,
@@ -30,14 +34,14 @@ import {
 	type BashCommand,
 } from './bash.js';
 
-// Whitespace (spaces and tabs, not newlines - those are significant)
+// Whitespace (spaces, tabs, and line continuations - not bare newlines which are significant)
 const bashInlineWhitespaceParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[ \t]+/),
+	createRegExpParser(/(?:[ \t]|\\\n)+/),
 	match => match[0],
 );
 
 const bashOptionalInlineWhitespaceParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[ \t]*/),
+	createRegExpParser(/(?:[ \t]|\\\n)*/),
 	match => match[0],
 );
 
@@ -49,26 +53,22 @@ const bashNewlineParser: Parser<string, string> = promiseCompose(
 
 // Word characters (unquoted, no special chars)
 // Note: {} are excluded so brace groups are parsed correctly
+// # is excluded from the first character (starts a comment) but allowed mid-word
 const bashUnquotedWordCharsParser: Parser<string, string> = promiseCompose(
-	createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#]+/),
+	createRegExpParser(/[^\s\n|&;<>(){}$`"'\\#][^\s\n|&;<>(){}$`"'\\]*/),
 	match => match[0],
 );
 
 // Single quoted string: '...'
-const bashSingleQuotedParser: Parser<BashWordPartSingleQuoted, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser("'"),
-		promiseCompose(
-			createRegExpParser(/[^']*/),
-			match => match[0],
-		),
-		createExactSequenceParser("'"),
-	]),
-	([, value]) => ({
-		type: 'singleQuoted' as const,
-		value,
-	}),
-);
+const bashSingleQuotedParser: Parser<BashWordPartSingleQuoted, string> = createObjectParser({
+	type: 'singleQuoted' as const,
+	_open: createExactSequenceParser("'"),
+	value: promiseCompose(
+		createRegExpParser(/[^']*/),
+		match => match[0],
+	),
+	_close: createExactSequenceParser("'"),
+});
 
 // Variable name
 const bashVariableNameParser: Parser<string, string> = promiseCompose(
@@ -77,47 +77,84 @@ const bashVariableNameParser: Parser<string, string> = promiseCompose(
 );
 
 // Simple variable: $var
-const bashSimpleVariableParser: Parser<BashWordPartVariable, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('$'),
-		bashVariableNameParser,
-	]),
-	([, name]) => ({
-		type: 'variable' as const,
-		name,
-	}),
-);
+const bashSimpleVariableParser: Parser<BashWordPartVariable, string> = createObjectParser({
+	type: 'variable' as const,
+	_dollar: createExactSequenceParser('$'),
+	name: bashVariableNameParser,
+});
 
 // Command substitution: $(...)
-const bashCommandSubstitutionParser: Parser<BashWordPartCommandSubstitution, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('$('),
-		bashOptionalInlineWhitespaceParser,
-		createParserAccessorParser(() => bashCommandParser),
-		bashOptionalInlineWhitespaceParser,
-		createExactSequenceParser(')'),
-	]),
-	([, , command]) => ({
-		type: 'commandSubstitution' as const,
-		command,
-	}),
-);
+const bashCommandSubstitutionParser: Parser<BashWordPartCommandSubstitution, string> = createObjectParser({
+	type: 'commandSubstitution' as const,
+	_open: createExactSequenceParser('$('),
+	_ws1: bashOptionalInlineWhitespaceParser,
+	command: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser(')'),
+});
 
 // Backtick substitution: `...`
-const bashBacktickSubstitutionParser: Parser<BashWordPartBacktickSubstitution, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('`'),
-		createParserAccessorParser(() => bashCommandParser),
-		createExactSequenceParser('`'),
-	]),
-	([, command]) => ({
-		type: 'backtickSubstitution' as const,
-		command,
-	}),
-);
+const bashBacktickSubstitutionParser: Parser<BashWordPartBacktickSubstitution, string> = createObjectParser({
+	type: 'backtickSubstitution' as const,
+	_open: createExactSequenceParser('`'),
+	command: createParserAccessorParser(() => bashCommandParser),
+	_close: createExactSequenceParser('`'),
+});
+
+// Braced variable expansion: ${VAR} or ${VAR:-default}
+const bashBracedVariableParser: Parser<BashWordPartVariableBraced, string> = createObjectParser({
+	type: 'variableBraced' as const,
+	_open: createExactSequenceParser('${'),
+	name: bashVariableNameParser,
+	operator: createOptionalParser(promiseCompose(
+		createRegExpParser(/:-|:=|:\+|:\?|-|=|\+|\?|##|#|%%|%/),
+		match => match[0],
+	)),
+	operand: createOptionalParser(createParserAccessorParser(() => bashWordParser)),
+	_close: createExactSequenceParser('}'),
+});
+
+// Arithmetic expansion: $((expression))
+const bashArithmeticExpansionParser: Parser<BashWordPartArithmeticExpansion, string> = createObjectParser({
+	type: 'arithmeticExpansion' as const,
+	_open: createExactSequenceParser('$(('),
+	expression: promiseCompose(
+		createRegExpParser(/(?:[^)]|\)(?!\)))*/),
+		match => match[0],
+	),
+	_close: createExactSequenceParser('))'),
+});
+
+// ANSI-C quoting: $'...'
+const bashAnsiCQuotedParser: Parser<BashWordPartSingleQuoted, string> = createObjectParser({
+	type: 'singleQuoted' as const,
+	_prefix: createExactSequenceParser('$'),
+	_open: createExactSequenceParser("'"),
+	value: promiseCompose(
+		createRegExpParser(/(?:[^'\\]|\\.)*/),
+		match => match[0],
+	),
+	_close: createExactSequenceParser("'"),
+});
+
+// Process substitution: <(cmd) or >(cmd)
+const bashProcessSubstitutionParser: Parser<BashWordPartProcessSubstitution, string> = createObjectParser({
+	type: 'processSubstitution' as const,
+	direction: promiseCompose(
+		createRegExpParser(/[<>](?=\()/),
+		match => match[0] as '<' | '>',
+	),
+	_open: createExactSequenceParser('('),
+	_ws1: bashOptionalInlineWhitespaceParser,
+	command: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser(')'),
+});
 
 // Double quoted string parts (inside "...")
 const bashDoubleQuotedPartParser: Parser<BashWordPart, string> = createDisjunctionParser([
+	bashBracedVariableParser,
+	bashArithmeticExpansionParser,
 	bashSimpleVariableParser,
 	bashCommandSubstitutionParser,
 	bashBacktickSubstitutionParser,
@@ -137,29 +174,37 @@ const bashDoubleQuotedPartParser: Parser<BashWordPart, string> = createDisjuncti
 			value: match[0],
 		}),
 	),
+	// Bare $ not followed by a valid expansion start (e.g. $" at end of double-quoted string)
+	promiseCompose(
+		createRegExpParser(/\$/),
+		() => ({
+			type: 'literal' as const,
+			value: '$',
+		}),
+	),
+	// Bare \ not followed by a recognized escape character (treated as literal backslash in bash)
+	promiseCompose(
+		createRegExpParser(/\\/),
+		() => ({
+			type: 'literal' as const,
+			value: '\\',
+		}),
+	),
 ]);
 
 // Double quoted string: "..."
-const bashDoubleQuotedParser: Parser<BashWordPartDoubleQuoted, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('"'),
-		createArrayParser(bashDoubleQuotedPartParser),
-		createExactSequenceParser('"'),
-	]),
-	([, parts]) => ({
-		type: 'doubleQuoted' as const,
-		parts,
-	}),
-);
+const bashDoubleQuotedParser: Parser<BashWordPartDoubleQuoted, string> = createObjectParser({
+	type: 'doubleQuoted' as const,
+	_open: createExactSequenceParser('"'),
+	parts: createArrayParser(bashDoubleQuotedPartParser),
+	_close: createExactSequenceParser('"'),
+});
 
 // Literal word part (unquoted)
-const bashLiteralWordPartParser: Parser<BashWordPartLiteral, string> = promiseCompose(
-	bashUnquotedWordCharsParser,
-	value => ({
-		type: 'literal' as const,
-		value,
-	}),
-);
+const bashLiteralWordPartParser: Parser<BashWordPartLiteral, string> = createObjectParser({
+	type: 'literal' as const,
+	value: bashUnquotedWordCharsParser,
+});
 
 // Escape sequence outside quotes
 const bashEscapeParser: Parser<BashWordPartLiteral, string> = promiseCompose(
@@ -172,37 +217,42 @@ const bashEscapeParser: Parser<BashWordPartLiteral, string> = promiseCompose(
 
 // Word part (any part of a word)
 const bashWordPartParser: Parser<BashWordPart, string> = createDisjunctionParser([
+	bashAnsiCQuotedParser,
 	bashSingleQuotedParser,
 	bashDoubleQuotedParser,
+	bashBracedVariableParser,
+	bashArithmeticExpansionParser,
 	bashCommandSubstitutionParser,
 	bashBacktickSubstitutionParser,
 	bashSimpleVariableParser,
+	bashProcessSubstitutionParser,
 	bashEscapeParser,
 	bashLiteralWordPartParser,
+	// Bare $ not followed by a valid expansion start
+	promiseCompose(
+		createRegExpParser(/\$/),
+		() => ({
+			type: 'literal' as const,
+			value: '$',
+		}),
+	),
 ]);
 
 // Word (sequence of word parts)
-export const bashWordParser: Parser<BashWord, string> = promiseCompose(
-	createNonEmptyArrayParser(bashWordPartParser),
-	parts => ({ parts }),
-);
+export const bashWordParser: Parser<BashWord, string> = createObjectParser({
+	parts: createNonEmptyArrayParser(bashWordPartParser),
+});
 
 setParserName(bashWordParser, 'bashWordParser');
 
 // Assignment: NAME=value or NAME=
-const bashAssignmentParser: Parser<BashAssignment, string> = promiseCompose(
-	createTupleParser([
-		promiseCompose(
-			createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/),
-			match => match[0].slice(0, -1),
-		),
-		createOptionalParser(bashWordParser),
-	]),
-	([name, value]) => ({
-		name,
-		value: value ?? undefined,
-	}),
-);
+const bashAssignmentParser: Parser<BashAssignment, string> = createObjectParser({
+	name: promiseCompose(
+		createRegExpParser(/[a-zA-Z_][a-zA-Z0-9_]*=/),
+		match => match[0].slice(0, -1),
+	),
+	value: createOptionalParser(bashWordParser),
+});
 
 // Redirect operators
 const bashRedirectOperatorParser: Parser<BashRedirect['operator'], string> = createDisjunctionParser([
@@ -217,22 +267,15 @@ const bashRedirectOperatorParser: Parser<BashRedirect['operator'], string> = cre
 ]);
 
 // Redirect: [n]op word
-const bashRedirectParser: Parser<BashRedirect, string> = promiseCompose(
-	createTupleParser([
-		createOptionalParser(promiseCompose(
-			createRegExpParser(/[0-9]+/),
-			match => Number.parseInt(match[0], 10),
-		)),
-		bashRedirectOperatorParser,
-		bashOptionalInlineWhitespaceParser,
-		bashWordParser,
-	]),
-	([fd, operator, , target]) => ({
-		fd: fd ?? undefined,
-		operator,
-		target,
-	}),
-);
+const bashRedirectParser: Parser<BashRedirect, string> = createObjectParser({
+	fd: createOptionalParser(promiseCompose(
+		createRegExpParser(/[0-9]+/),
+		match => Number.parseInt(match[0], 10),
+	)),
+	operator: bashRedirectOperatorParser,
+	_ws: bashOptionalInlineWhitespaceParser,
+	target: bashWordParser,
+});
 
 // Word with optional trailing whitespace - for use in arrays
 const bashWordWithWhitespaceParser: Parser<BashWord, string> = promiseCompose(
@@ -254,8 +297,8 @@ const bashRedirectWithWhitespaceParser: Parser<BashRedirect, string> = promiseCo
 
 // Word or redirect - for interleaved parsing in simple commands
 const bashWordOrRedirectParser: Parser<{ type: 'word'; word: BashWord } | { type: 'redirect'; redirect: BashRedirect }, string> = createDisjunctionParser([
-	promiseCompose(bashRedirectWithWhitespaceParser, redirect => ({ type: 'redirect' as const, redirect })),
-	promiseCompose(bashWordWithWhitespaceParser, word => ({ type: 'word' as const, word })),
+	createObjectParser({ type: 'redirect' as const, redirect: bashRedirectWithWhitespaceParser }),
+	createObjectParser({ type: 'word' as const, word: bashWordWithWhitespaceParser }),
 ]);
 
 // Simple command: [assignments] [name] [args] [redirects]
@@ -299,38 +342,28 @@ export const bashSimpleCommandParser: Parser<BashSimpleCommand, string> = promis
 setParserName(bashSimpleCommandParser, 'bashSimpleCommandParser');
 
 // Subshell: ( command )
-const bashSubshellParser: Parser<BashSubshell, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('('),
-		bashOptionalInlineWhitespaceParser,
-		createParserAccessorParser(() => bashCommandParser),
-		bashOptionalInlineWhitespaceParser,
-		createExactSequenceParser(')'),
-	]),
-	([, , body]) => ({
-		type: 'subshell' as const,
-		body,
-	}),
-);
+const bashSubshellParser: Parser<BashSubshell, string> = createObjectParser({
+	type: 'subshell' as const,
+	_open: createExactSequenceParser('('),
+	_ws1: bashOptionalInlineWhitespaceParser,
+	body: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser(')'),
+});
 
 setParserName(bashSubshellParser, 'bashSubshellParser');
 
 // Brace group: { command; }
-const bashBraceGroupParser: Parser<BashBraceGroup, string> = promiseCompose(
-	createTupleParser([
-		createExactSequenceParser('{'),
-		bashInlineWhitespaceParser,
-		createParserAccessorParser(() => bashCommandParser),
-		bashOptionalInlineWhitespaceParser,
-		createOptionalParser(createExactSequenceParser(';')),
-		bashOptionalInlineWhitespaceParser,
-		createExactSequenceParser('}'),
-	]),
-	([, , body]) => ({
-		type: 'braceGroup' as const,
-		body,
-	}),
-);
+const bashBraceGroupParser: Parser<BashBraceGroup, string> = createObjectParser({
+	type: 'braceGroup' as const,
+	_open: createExactSequenceParser('{'),
+	_ws1: bashInlineWhitespaceParser,
+	body: createParserAccessorParser(() => bashCommandParser),
+	_ws2: bashOptionalInlineWhitespaceParser,
+	_semi: createOptionalParser(createExactSequenceParser(';')),
+	_ws3: bashOptionalInlineWhitespaceParser,
+	_close: createExactSequenceParser('}'),
+});
 
 setParserName(bashBraceGroupParser, 'bashBraceGroupParser');
 
@@ -390,15 +423,12 @@ const bashListSeparatorParser: Parser<'&&' | '||' | ';' | '&' | '\n', string> =
 const bashCommandListParser: Parser<BashCommandList, string> = promiseCompose(
 	createTupleParser([
 		bashPipelineParser,
-		createArrayParser(promiseCompose(
-			createTupleParser([
-				bashOptionalInlineWhitespaceParser,
-				bashListSeparatorParser,
-				bashOptionalInlineWhitespaceParser,
-				bashPipelineParser,
-			]),
-			([, separator, , pipeline]) => ({ separator, pipeline }),
-		)),
+		createArrayParser(createObjectParser({
+			_ws1: bashOptionalInlineWhitespaceParser,
+			separator: bashListSeparatorParser,
+			_ws2: bashOptionalInlineWhitespaceParser,
+			pipeline: bashPipelineParser,
+		})),
 		createOptionalParser(promiseCompose(
 			createTupleParser([
 				bashOptionalInlineWhitespaceParser,
@@ -448,12 +478,19 @@ export const bashCommandParser: Parser<BashCommand, string> = bashCommandListPar
 
 setParserName(bashCommandParser, 'bashCommandParser');
 
-// Script parser (handles leading/trailing whitespace)
+// Comment: # through end of line
+const bashOptionalCommentParser: Parser<string | undefined, string> = createOptionalParser(promiseCompose(
+	createRegExpParser(/#[^\n]*/),
+	match => match[0],
+));
+
+// Script parser (handles leading/trailing whitespace and comments)
 export const bashScriptParser: Parser<BashCommand, string> = promiseCompose(
 	createTupleParser([
 		bashOptionalInlineWhitespaceParser,
 		bashCommandParser,
 		bashOptionalInlineWhitespaceParser,
+		bashOptionalCommentParser,
 	]),
 	([, command]) => command,
 );