@futpib/parser 1.0.4 → 1.0.7

package/src/bashParser.test.ts

@@ -2,6 +2,7 @@ import test from 'ava';
 import { runParser, runParserWithRemainingInput } from './parser.js';
 import { stringParserInputCompanion } from './parserInputCompanion.js';
 import { bashScriptParser, bashWordParser, bashSimpleCommandParser } from './bashParser.js';
+import type { BashSimpleCommand, BashWordPartLiteral } from './bash.js';
 
 test('simple command parser - single word', async t => {
 	const result = await runParser(
@@ -166,6 +167,79 @@ test('double quoted string with variable', async t => {
 	}
 });
 
+test('double quoted string with trailing dollar', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo "hello$"',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.deepEqual(cmd.args[0], {
+			parts: [{
+				type: 'doubleQuoted',
+				parts: [
+					{ type: 'literal', value: 'hello' },
+					{ type: 'literal', value: '$' },
+				],
+			}],
+		});
+	}
+});
+
+test('double quoted string with only dollar', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo "$"',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.deepEqual(cmd.args[0], {
+			parts: [{
+				type: 'doubleQuoted',
+				parts: [
+					{ type: 'literal', value: '$' },
+				],
+			}],
+		});
+	}
+});
+
+test('grep with dollar anchor in double quotes', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'grep "\\.ts$"',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.deepEqual(cmd.args[0], {
+			parts: [{
+				type: 'doubleQuoted',
+				parts: [
+					{ type: 'literal', value: '\\' },
+					{ type: 'literal', value: '.ts' },
+					{ type: 'literal', value: '$' },
+				],
+			}],
+		});
+	}
+});
+
+test('pipeline with dollar anchor in double quoted grep pattern', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'ls -la /home | grep "\\.ts$" | grep -v "\\.test\\.ts"',
+		stringParserInputCompanion,
+	);
+
+	t.is(result.entries[0].pipeline.commands.length, 3);
+});
+
 test('simple variable', async t => {
 	const result = await runParser(
 		bashScriptParser,
@@ -318,6 +392,191 @@ test('[[ treated as command name', async t => {
 	}
 });
 
+// Braced variable expansion: ${VAR}
+test('braced variable expansion', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo ${HOME}',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.is(cmd.args[0].parts[0].type, 'variableBraced');
+	}
+});
+
+// Braced variable with default: ${VAR:-default}
+test('braced variable with default value', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo ${VAR:-default}',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.is(cmd.args[0].parts[0].type, 'variableBraced');
+	}
+});
+
+// Arithmetic expansion: $((1+2))
+test('arithmetic expansion', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo $((1+2))',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.is(cmd.args[0].parts[0].type, 'arithmeticExpansion');
+	}
+});
+
+// Bare $ at end of unquoted word
+test('bare dollar at end of unquoted word', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo foo$',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.deepEqual(cmd.args[0], {
+			parts: [
+				{ type: 'literal', value: 'foo' },
+				{ type: 'literal', value: '$' },
+			],
+		});
+	}
+});
+
+// Bare $ as its own unquoted word
+test('bare dollar as standalone unquoted word', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo $',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.deepEqual(cmd.args[0], {
+			parts: [
+				{ type: 'literal', value: '$' },
+			],
+		});
+	}
+});
+
+// Comment after command
+test('comment after command', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo hello # this is a comment',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.is(cmd.args.length, 1);
+		t.deepEqual(cmd.args[0], {
+			parts: [{ type: 'literal', value: 'hello' }],
+		});
+	}
+});
+
+// ANSI-C quoting: $'...'
+test('ansi-c quoting', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		"echo $'hello\\nworld'",
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.is(cmd.args.length, 1);
+	}
+});
+
+// Braced variable in double quotes: "${VAR}"
+test('braced variable in double quotes', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo "${HOME}"',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		const dq = cmd.args[0].parts[0];
+		if (dq.type === 'doubleQuoted') {
+			t.is(dq.parts[0].type, 'variableBraced');
+		}
+	}
+});
+
+// Arithmetic expansion in double quotes
+test('arithmetic expansion in double quotes', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo "$((1+2))"',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		const dq = cmd.args[0].parts[0];
+		if (dq.type === 'doubleQuoted') {
+			t.is(dq.parts[0].type, 'arithmeticExpansion');
+		}
+	}
+});
+
+// Process substitution: <(cmd)
+test('process substitution input', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'diff <(sort file1) <(sort file2)',
+		stringParserInputCompanion,
+	);
+
+	t.truthy(result);
+});
+
+// Line continuation (backslash-newline)
+test('line continuation', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo hello \\\nworld',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.is(cmd.args.length, 2);
+	}
+});
+
+// Hash in middle of unquoted word is literal, not a comment
+test('hash in middle of unquoted word', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo foo#bar',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0];
+	if (cmd.type === 'simple') {
+		t.deepEqual(cmd.args[0], {
+			parts: [{ type: 'literal', value: 'foo#bar' }],
+		});
+	}
+});
+
 test('if treated as command name', async t => {
 	const result = await runParser(
 		bashScriptParser,
@@ -330,3 +589,140 @@ test('if treated as command name', async t => {
 		t.deepEqual(cmd.name, { parts: [{ type: 'literal', value: 'if' }] });
 	}
 });
+
+test('find -exec with {} placeholder', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'find . -name "*.tmp" -exec rm {} \\;',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.is(cmd.name!.parts[0].type, 'literal');
+	t.is((cmd.name!.parts[0] as BashWordPartLiteral).value, 'find');
+	// {} should be parsed as a literal word argument
+	const braceArg = cmd.args[5]; // ., -name, "*.tmp", -exec, rm, {}, \;
+	t.is(braceArg.parts[0].type, 'literal');
+	t.is((braceArg.parts[0] as BashWordPartLiteral).value, '{}');
+});
+
+test('lone open brace as argument', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo {',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.deepEqual(cmd.args[0], {
+		parts: [{ type: 'literal', value: '{' }],
+	});
+});
+
+test('close brace mid-word', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo foo}bar',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.is(cmd.args.length, 1);
+	t.is(cmd.args[0].parts[0].type, 'literal');
+});
+
+test('open brace mid-word', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo foo{bar',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.is(cmd.args.length, 1);
+	t.is(cmd.args[0].parts[0].type, 'literal');
+});
+
+test('braces mid-word like brace expansion', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo file.{c,h}',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.is(cmd.args.length, 1);
+	t.is(cmd.args[0].parts[0].type, 'literal');
+});
+
+test('find -exec with {.} placeholder variant', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo {.}',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.is(cmd.args.length, 1);
+	t.is(cmd.args[0].parts[0].type, 'literal');
+});
+
+test('lone close brace as argument', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo }',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.deepEqual(cmd.args[0], {
+		parts: [{ type: 'literal', value: '}' }],
+	});
+});
+
+test('close brace at start of word', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo }hello',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	t.is(cmd.args.length, 1);
+	t.is(cmd.args[0].parts[0].type, 'literal');
+});
+
+test('multi-line script with blank lines', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo hello\n\necho world',
+		stringParserInputCompanion,
+	);
+
+	t.is(result.entries.length, 2);
+});
+
+test('mid-script comment', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo hello\n# comment\necho world',
+		stringParserInputCompanion,
+	);
+
+	t.is(result.entries.length, 2);
+});
+
+test('nested parentheses in arithmetic expansion', async t => {
+	const result = await runParser(
+		bashScriptParser,
+		'echo $((1 + (2 * 3)))',
+		stringParserInputCompanion,
+	);
+
+	const cmd = result.entries[0].pipeline.commands[0] as BashSimpleCommand;
+	const arith = cmd.args[0].parts[0];
+	t.is(arith.type, 'arithmeticExpansion');
+	if (arith.type === 'arithmeticExpansion') {
+		t.is(arith.expression, '1 + (2 * 3)');
+	}
+});