@futpib/parser 1.0.6 → 1.0.8

package/build/arbitraryBash.d.ts

@@ -0,0 +1,3 @@
+import * as fc from 'fast-check';
+import { type BashCommandList } from './bash.js';
+export declare const arbitraryBashCommandList: fc.Arbitrary<BashCommandList>;

package/build/arbitraryBash.js

@@ -0,0 +1,142 @@
+import * as fc from 'fast-check';
+const arbitraryBashIdentifier = fc.stringMatching(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+// Safe unquoted literal: no shell special chars, no leading {/} or #, no = (would be parsed as assignment)
+const arbitraryBashWordPartLiteral = fc.record({
+    type: fc.constant('literal'),
+    value: fc.stringMatching(/^[a-zA-Z0-9][a-zA-Z0-9._@%,:^~-]*$/),
+});
+// Single-quoted: no single quotes, no newlines inside (keep simple)
+const arbitraryBashWordPartSingleQuoted = fc.record({
+    type: fc.constant('singleQuoted'),
+    value: fc.stringMatching(/^[^'\n]*$/),
+});
+const arbitraryBashWordPartVariable = fc.record({
+    type: fc.constant('variable'),
+    name: arbitraryBashIdentifier,
+});
+// variableBraced without operator/operand (always include the optional keys so deepEqual matches parser output)
+const arbitraryBashWordPartVariableBraced = fc.record({
+    type: fc.constant('variableBraced'),
+    name: arbitraryBashIdentifier,
+    operator: fc.constant(undefined),
+    operand: fc.constant(undefined),
+});
+const arbitraryBashWordPartArithmeticExpansion = fc.record({
+    type: fc.constant('arithmeticExpansion'),
+    expression: fc.stringMatching(/^[0-9+\- ]*$/),
+});
+const recursiveArbitraries = fc.letrec(tie => {
+    const arbitraryCommandList = tie('commandList');
+    // Double-quoted literal: no shell-special chars inside double quotes
+    const arbitraryDoubleQuotedLiteral = fc.record({
+        type: fc.constant('literal'),
+        value: fc.stringMatching(/^[^"\\$`\n]+$/),
+    });
+    const arbitraryBashWordPartDoubleQuoted = fc.record({
+        type: fc.constant('doubleQuoted'),
+        parts: fc.array(fc.oneof({ weight: 3, arbitrary: arbitraryDoubleQuotedLiteral }, { weight: 1, arbitrary: arbitraryBashWordPartVariable }, { weight: 1, arbitrary: arbitraryBashWordPartVariableBraced }), { minLength: 1, maxLength: 3 }),
+    }).filter(dq => dq.parts.every((part, i) => {
+        const next = dq.parts[i + 1];
+        // Prevent adjacent literal parts (they merge when re-parsed)
+        if (part.type === 'literal' && next !== undefined && next.type === 'literal') {
+            return false;
+        }
+        // Prevent $var followed by literal starting with ident char (would be mis-parsed as one variable)
+        if (part.type === 'variable' && next !== undefined && next.type === 'literal') {
+            return next.value.length === 0 || !isIdentChar(next.value[0]);
+        }
+        return true;
+    }));
+    const arbitraryBashWordPartCommandSubstitution = fc.record({
+        type: fc.constant('commandSubstitution'),
+        command: arbitraryCommandList,
+    });
+    const arbitraryBashWordPart = fc.oneof({ weight: 4, arbitrary: arbitraryBashWordPartLiteral }, { weight: 2, arbitrary: arbitraryBashWordPartSingleQuoted }, { weight: 2, arbitrary: arbitraryBashWordPartDoubleQuoted }, { weight: 2, arbitrary: arbitraryBashWordPartVariable }, { weight: 1, arbitrary: arbitraryBashWordPartVariableBraced }, { weight: 1, arbitrary: arbitraryBashWordPartArithmeticExpansion }, { weight: 1, arbitrary: arbitraryBashWordPartCommandSubstitution });
+    function isIdentChar(ch) {
+        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch === '_';
+    }
+    const arbitraryWord = fc.record({
+        parts: fc.array(arbitraryBashWordPart, { minLength: 1, maxLength: 2 }),
+    }).filter(word => word.parts.every((part, i) => {
+        const next = word.parts[i + 1];
+        // Prevent adjacent literal parts (they merge when re-parsed)
+        if (part.type === 'literal' && next !== undefined && next.type === 'literal') {
+            return false;
+        }
+        // Prevent $var followed by literal starting with ident char (would be mis-parsed as one variable)
+        if (part.type === 'variable' && next !== undefined && next.type === 'literal') {
+            return next.value.length === 0 || !isIdentChar(next.value[0]);
+        }
+        return true;
+    }));
+    // Always include value key (even if undefined) to match createObjectParser behavior
+    const arbitraryBashAssignment = fc.record({
+        name: arbitraryBashIdentifier,
+        value: fc.option(arbitraryWord, { nil: undefined }),
+    });
+    // Always include fd key (even if undefined) to match createObjectParser behavior
+    const arbitraryBashRedirect = fc.record({
+        fd: fc.constant(undefined),
+        operator: fc.oneof(fc.constant('>'), fc.constant('>>'), fc.constant('<')),
+        target: arbitraryWord,
+    });
+    const arbitraryBashSimpleCommandWithName = fc.record({
+        type: fc.constant('simple'),
+        name: arbitraryWord,
+        args: fc.array(arbitraryWord, { maxLength: 2 }),
+        redirects: fc.array(arbitraryBashRedirect, { maxLength: 1 }),
+        assignments: fc.array(arbitraryBashAssignment, { maxLength: 1 }),
+    });
+    // Commands with no name: only assignments and/or redirects (no args)
+    const arbitraryBashSimpleCommandNoName = fc.record({
+        type: fc.constant('simple'),
+        name: fc.constant(undefined),
+        args: fc.constant([]),
+        redirects: fc.array(arbitraryBashRedirect, { maxLength: 1 }),
+        assignments: fc.array(arbitraryBashAssignment, { minLength: 1, maxLength: 2 }),
+    });
+    const arbitraryBashSimpleCommand = fc.oneof({ weight: 4, arbitrary: arbitraryBashSimpleCommandWithName }, { weight: 1, arbitrary: arbitraryBashSimpleCommandNoName });
+    const arbitraryBashSubshell = fc.record({
+        type: fc.constant('subshell'),
+        body: arbitraryCommandList,
+    });
+    // Brace group bodies need trailing ';' on last entry (required by "{ cmd; }" syntax)
+    const arbitraryBraceGroupBody = arbitraryCommandList.map(list => {
+        const entries = list.entries.map((entry, i) => {
+            if (i === list.entries.length - 1 && entry.separator === undefined) {
+                return { pipeline: entry.pipeline, separator: ';' };
+            }
+            return entry;
+        });
+        return { ...list, entries };
+    });
+    const arbitraryBashBraceGroup = fc.record({
+        type: fc.constant('braceGroup'),
+        body: arbitraryBraceGroupBody,
+    });
+    const arbitraryBashCommandUnit = fc.oneof({ weight: 5, arbitrary: arbitraryBashSimpleCommand }, { weight: 1, arbitrary: arbitraryBashSubshell }, { weight: 1, arbitrary: arbitraryBashBraceGroup });
+    const arbitraryBashPipeline = fc.record({
+        type: fc.constant('pipeline'),
+        negated: fc.boolean(),
+        commands: fc.array(arbitraryBashCommandUnit, { minLength: 1, maxLength: 2 }),
+    });
+    const commandListArbitrary = fc.record({
+        type: fc.constant('list'),
+        entries: fc.array(fc.record({
+            pipeline: arbitraryBashPipeline,
+            separator: fc.option(fc.oneof(fc.constant('&&'), fc.constant('||'), fc.constant(';')), { nil: undefined }),
+        }), { minLength: 1, maxLength: 2 }),
+    }).map(list => {
+        const entries = list.entries.map((entry, i) => {
+            if (i < list.entries.length - 1 && entry.separator === undefined) {
+                return { pipeline: entry.pipeline, separator: ';' };
+            }
+            return entry;
+        });
+        return { ...list, entries };
+    });
+    return {
+        commandList: commandListArbitrary,
+    };
+});
+export const arbitraryBashCommandList = recursiveArbitraries.commandList;

package/build/arbitraryJavaScript.js

@@ -164,7 +164,7 @@ const arbitraryFunctionBodyBlockStatement = fc.record({
 const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
     type: fc.constant('ArrowFunctionExpression'),
     id: fc.constant(null),
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryFunctionBodyBlockStatement,
     expression: fc.constant(false),
     generator: fc.constant(false),
@@ -172,7 +172,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
 }), fc.record({
     type: fc.constant('ArrowFunctionExpression'),
     id: fc.constant(null),
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryLeafExpression,
     expression: fc.constant(true),
     generator: fc.constant(false),
@@ -181,7 +181,7 @@ const arbitraryArrowFunctionExpression = fc.oneof(fc.record({
 const arbitraryFunctionExpression = fc.record({
     type: fc.constant('FunctionExpression'),
     id: fc.constant(null),
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryFunctionBodyBlockStatement,
     expression: fc.constant(false),
     generator: fc.constant(false),
@@ -232,7 +232,7 @@ const arbitraryTryStatement = fc.oneof(fc.record({
 const arbitraryFunctionDeclaration = fc.record({
     type: fc.constant('FunctionDeclaration'),
     id: arbitraryIdentifier,
-    params: fc.array(arbitraryIdentifier, { minLength: 0, maxLength: 3 }),
+    params: fc.uniqueArray(arbitraryIdentifier, { minLength: 0, maxLength: 3, selector: (id) => id.name }),
     body: arbitraryFunctionBodyBlockStatement,
     expression: fc.constant(false),
     generator: fc.constant(false),

package/build/arbitraryZipStream.d.ts

@@ -2,4 +2,4 @@ import { type ZipEntry } from './zip.js';
 export declare const arbitraryZipStream: import("fast-check").Arbitrary<readonly [{
     comment: string;
     entries: ZipEntry[];
-}, import("stream/web").ReadableStream<Uint8Array<ArrayBufferLike>>]>;
+}, import("node:stream/web").ReadableStream<Uint8Array<ArrayBufferLike>>]>;