bupkis 0.18.2 → 1.0.0

package/dist/expect.cjs

@@ -0,0 +1,587 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpectAsyncFunction = createExpectAsyncFunction;
+exports.createExpectSyncFunction = createExpectSyncFunction;
+exports.createBaseExpect = createBaseExpect;
+const obug_1 = require("obug");
+const util_1 = require("util");
+const create_js_1 = require("./assertion/create.cjs");
+const error_js_1 = require("./error.cjs");
+const guards_js_1 = require("./guards.cjs");
+const use_js_1 = require("./use.cjs");
+const debug = (0, obug_1.createDebug)('bupkis:expect');
+/**
+ * Implementation function that creates an asynchronous expect function with
+ * optional parent inheritance.
+ *
+ * This is the concrete implementation that handles both overload cases for
+ * Promise-based assertions. It creates an expectAsync function that uses a
+ * two-phase matching algorithm: first seeking exact phrase matches for optimal
+ * performance, then falling back to partial matches if needed. The function
+ * processes negation keywords, combines parent assertions with new ones, and
+ * ensures all operations are properly awaited.
+ *
+ * The matching algorithm prioritizes exact matches to minimize performance
+ * overhead, but provides flexibility through partial matching when exact
+ * phrases don't align. This enables natural language flexibility while
+ * maintaining execution speed for common async assertion patterns.
+ *
+ * @remarks
+ * The function performs async assertion matching in the following order:
+ *
+ * 1. Awaits `Promise.resolve()` to ensure the function is always asynchronous
+ * 2. Processes negation keywords ('not', 'to not') to determine assertion mode
+ * 3. Combines parent assertions (if provided) with new assertions in execution
+ *    order
+ * 4. Attempts to parse arguments against each assertion's expected phrase pattern
+ *    using `parseValuesAsync`
+ * 5. Prioritizes exact phrase matches over partial matches for performance
+ * 6. Executes the first successful match using {@link executeAsync} or throws an
+ *    error if none found
+ *
+ * Performance considerations: The function loops through all available
+ * assertions for each call, but uses early termination when exact matches are
+ * found. For performance-critical code, consider using assertion functions with
+ * fewer total assertions or more specific phrase patterns to reduce matching
+ * overhead.
+ *
+ * All assertion execution is properly awaited to handle Promise-based
+ * validation logic, error handling, and negation scenarios in asynchronous
+ * contexts.
+ * @example
+ *
+ * ```typescript
+ * // Used internally by both public overloads
+ * const expectAsync1 = createExpectAsyncFunction(assertions); // No parent
+ * const expectAsync2 = createExpectAsyncFunction(assertions, parent); // With parent
+ * ```
+ *
+ * @param assertions - Array of asynchronous assertion objects to make available
+ * @param expect - Optional parent expectAsync function to inherit assertions
+ *   from
+ * @returns Asynchronous expect function that processes natural language
+ *   assertions with Promise support
+ * @throws {@link AssertionError} When an assertion fails in normal
+ *   (non-negated) mode
+ * @throws {@link NegatedAssertionError} When a negated assertion fails (e.g.,
+ *   `await expectAsync(promise, 'not to resolve')`)
+ * @throws {Error} When no matching assertion can be found for the provided
+ *   arguments
+ * @internal This is the concrete implementation used by the public overloads
+ * @see {@link createExpectSyncFunction} for creating synchronous expect functions
+ * @see {@link createAsyncAssertion} for creating individual async assertion objects
+ * @see {@link ExpectAsync} for the main expectAsync interface
+ */
+function createExpectAsyncFunction(assertions, expect) {
+    // Combine all assertions once at creation time
+    const allAssertions = [
+        ...(expect?.assertions ?? []),
+        ...assertions,
+    ];
+    // Build phrase index for fast dispatch
+    const phraseIndex = buildPhraseIndex(allAssertions);
+    debug('ℹ Creating expectAsync function with %d new assertions and %d existing assertions (%d total, %d indexed phrases)', assertions.length, expect?.assertions.length ?? 0, allAssertions.length, phraseIndex.size);
+    /**
+     * @function
+     */
+    const expectAsyncFunction = async (...args) => {
+        await Promise.resolve();
+        const argsMatrix = conjunctify(args);
+        // First, try all conjunctified argument sets
+        let foundCount = 0;
+        for (const args of argsMatrix) {
+            const { isNegated, processedArgs } = maybeProcessNegation(args);
+            const candidates = [];
+            // Use phrase index for O(1) candidate lookup, fall back to full scan
+            const assertionsToCheck = getCandidateAssertions(processedArgs, phraseIndex, allAssertions);
+            for (const assertion of assertionsToCheck) {
+                const parseResult = await assertion.parseValuesAsync(processedArgs);
+                const { exactMatch, parsedValues, success } = parseResult;
+                if (success) {
+                    if (exactMatch) {
+                        foundCount++;
+                        await executeAsync(assertion, parsedValues, [...args], expectAsyncFunction, isNegated, parseResult);
+                        break;
+                    }
+                    candidates.push({ assertion, parseResult });
+                }
+            }
+            if (candidates.length) {
+                const { assertion, parseResult } = candidates[0];
+                foundCount++;
+                await executeAsync(assertion, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                parseResult.parsedValues, [...args], expectAsyncFunction, isNegated, parseResult);
+            }
+        }
+        if (foundCount >= argsMatrix.length) {
+            return;
+        }
+        // Fallback: if all conjunctified attempts failed and we actually split on "and",
+        // try different permutations of rejoining the split parts
+        if (argsMatrix.length > 1) {
+            const rejoinPermutations = generateRejoinPermutations(argsMatrix, args);
+            for (const permutation of rejoinPermutations) {
+                const { isNegated, processedArgs } = maybeProcessNegation(permutation);
+                const candidates = [];
+                // Use phrase index for O(1) candidate lookup, fall back to full scan
+                const assertionsToCheck = getCandidateAssertions(processedArgs, phraseIndex, allAssertions);
+                for (const assertion of assertionsToCheck) {
+                    const parseResult = await assertion.parseValuesAsync(processedArgs);
+                    const { exactMatch, parsedValues, success } = parseResult;
+                    if (success) {
+                        if (exactMatch) {
+                            await executeAsync(assertion, parsedValues, [...permutation], expectAsyncFunction, isNegated, parseResult);
+                            return;
+                        }
+                        candidates.push({ assertion, parseResult });
+                    }
+                }
+                if (candidates.length) {
+                    const { assertion, parseResult } = candidates[0];
+                    await executeAsync(assertion, 
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    parseResult.parsedValues, [...permutation], expectAsyncFunction, isNegated, parseResult);
+                    return;
+                }
+            }
+        }
+        throwInvalidParametersError(args);
+    };
+    return expectAsyncFunction;
+}
+/**
+ * Implementation function that creates a synchronous expect function with
+ * optional parent inheritance.
+ *
+ * This is the concrete implementation that handles both overload cases. It
+ * creates an expect function that uses a two-phase matching algorithm: first
+ * seeking exact phrase matches for optimal performance, then falling back to
+ * partial matches if needed. The function processes negation keywords and
+ * combines parent assertions with new ones.
+ *
+ * The matching algorithm prioritizes exact matches to minimize performance
+ * overhead, but provides flexibility through partial matching when exact
+ * phrases don't align. This enables natural language flexibility while
+ * maintaining execution speed for common assertion patterns.
+ *
+ * @remarks
+ * The function performs assertion matching in the following order:
+ *
+ * 1. Processes negation keywords ('not', 'to not') to determine assertion mode
+ * 2. Combines parent assertions (if provided) with new assertions in execution
+ *    order
+ * 3. Attempts to parse arguments against each assertion's expected phrase pattern
+ * 4. Prioritizes exact phrase matches over partial matches for performance
+ * 5. Executes the first successful match or throws an error if none found
+ *
+ * Performance considerations: The function loops through all available
+ * assertions for each call, but uses early termination when exact matches are
+ * found. For performance-critical code, consider using assertion functions with
+ * fewer total assertions or more specific phrase patterns to reduce matching
+ * overhead.
+ * @example
+ *
+ * ```typescript
+ * // Used internally by both public overloads
+ * const expect1 = createExpectSyncFunction(assertions); // No parent
+ * const expect2 = createExpectSyncFunction(assertions, parent); // With parent
+ * ```
+ *
+ * @param assertions - Array of synchronous assertion objects to make available
+ * @param expect - Optional parent expect function to inherit assertions from
+ * @returns Synchronous expect function that processes natural language
+ *   assertions
+ * @throws {@link AssertionError} When an assertion fails in normal
+ *   (non-negated) mode
+ * @throws {@link NegatedAssertionError} When a negated assertion fails (e.g.,
+ *   `expect(42, 'not to be a number')`)
+ * @throws {Error} When no matching assertion can be found for the provided
+ *   arguments
+ * @internal This is the concrete implementation used by the public overloads
+ * @see {@link createExpectAsyncFunction} for creating asynchronous expect functions
+ * @see {@link createAssertion} for creating individual assertion objects
+ * @see {@link Expect} for the main expect interface
+ */
+function createExpectSyncFunction(assertions, expect) {
+    // Combine all assertions once at creation time
+    const allAssertions = [
+        ...(expect?.assertions ?? []),
+        ...assertions,
+    ];
+    // Build phrase index for fast dispatch
+    const phraseIndex = buildPhraseIndex(allAssertions);
+    debug('ℹ Creating expect function with %d new assertions and %d existing assertions (%d total, %d indexed phrases)', assertions.length, expect?.assertions.length ?? 0, allAssertions.length, phraseIndex.size);
+    /**
+     * @function
+     */
+    const expectFunction = (...args) => {
+        const argsMatrix = conjunctify(args);
+        // First, try all conjunctified argument sets
+        let foundCount = 0;
+        for (const args of argsMatrix) {
+            const { isNegated, processedArgs } = maybeProcessNegation(args);
+            const candidates = [];
+            // Use phrase index for O(1) candidate lookup, fall back to full scan
+            const assertionsToCheck = getCandidateAssertions(processedArgs, phraseIndex, allAssertions);
+            for (const assertion of assertionsToCheck) {
+                const parseResult = assertion.parseValues(processedArgs);
+                const { exactMatch, parsedValues, success } = parseResult;
+                if (success) {
+                    if (exactMatch) {
+                        foundCount++;
+                        execute(assertion, parsedValues, [...args], expectFunction, isNegated, parseResult);
+                        break;
+                    }
+                    candidates.push({ assertion, parseResult });
+                }
+            }
+            if (candidates.length) {
+                const { assertion, parseResult } = candidates[0];
+                foundCount++;
+                execute(assertion, 
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                parseResult.parsedValues, [...args], expectFunction, isNegated, parseResult);
+            }
+        }
+        if (foundCount >= argsMatrix.length) {
+            return;
+        }
+        // Fallback: if all conjunctified attempts failed and we actually split on "and",
+        // try different permutations of rejoining the split parts
+        if (argsMatrix.length > 1) {
+            const rejoinPermutations = generateRejoinPermutations(argsMatrix, args);
+            for (const permutation of rejoinPermutations) {
+                const { isNegated, processedArgs } = maybeProcessNegation(permutation);
+                const candidates = [];
+                // Use phrase index for O(1) candidate lookup, fall back to full scan
+                const assertionsToCheck = getCandidateAssertions(processedArgs, phraseIndex, allAssertions);
+                for (const assertion of assertionsToCheck) {
+                    const parseResult = assertion.parseValues(processedArgs);
+                    const { exactMatch, parsedValues, success } = parseResult;
+                    if (success) {
+                        if (exactMatch) {
+                            execute(assertion, parsedValues, [...permutation], expectFunction, isNegated, parseResult);
+                            return;
+                        }
+                        candidates.push({ assertion, parseResult });
+                    }
+                }
+                if (candidates.length) {
+                    const { assertion, parseResult } = candidates[0];
+                    execute(assertion, 
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    parseResult.parsedValues, [...permutation], expectFunction, isNegated, parseResult);
+                    return;
+                }
+            }
+        }
+        throwInvalidParametersError(args);
+    };
+    return expectFunction;
+}
+/**
+ * Executes an assertion with optional negation logic.
+ *
+ * @privateRemarks
+ * This is here because `Assertion` doesn't know anything about negation and
+ * probably shouldn't.
+ * @function
+ * @param assertion - The assertion to execute
+ * @param parsedValues - Parsed values for the assertion
+ * @param args - Original arguments passed to expect
+ * @param stackStartFn - Function for stack trace management
+ * @param isNegated - Whether the assertion should be negated
+ */
+const execute = (assertion, parsedValues, args, stackStartFn, isNegated, parseResult) => {
+    try {
+        assertion.execute(parsedValues, args, stackStartFn, parseResult);
+    }
+    catch (error) {
+        handleAssertionError(error, assertion, isNegated);
+        return;
+    }
+    if (isNegated) {
+        throwNegatedAssertionPassedError(assertion, stackStartFn);
+    }
+};
+/**
+ * Executes an assertion with optional negation logic (async version).
+ *
+ * @privateRemarks
+ * This is here because `Assertion` doesn't know anything about negation and
+ * probably shouldn't.
+ * @function
+ * @param assertion - The assertion to execute
+ * @param parsedValues - Parsed values for the assertion
+ * @param args - Original arguments passed to expectAsync
+ * @param stackStartFn - Function for stack trace management
+ * @param isNegated - Whether the assertion should be negated
+ */
+const executeAsync = async (assertion, parsedValues, args, stackStartFn, isNegated, parseResult) => {
+    try {
+        await assertion.executeAsync(parsedValues, args, stackStartFn, parseResult);
+    }
+    catch (error) {
+        handleAssertionError(error, assertion, isNegated);
+        return;
+    }
+    if (isNegated) {
+        throwNegatedAssertionPassedError(assertion, stackStartFn);
+    }
+};
+/**
+ * Handles errors thrown during assertion execution.
+ *
+ * @function
+ * @param error - The error that was thrown
+ * @param assertion - The assertion that threw the error
+ * @param isNegated - Whether the assertion was negated
+ * @returns Void if error should be swallowed (negated assertion success)
+ * @throws The original error if it's an AssertionError (non-negated case)
+ * @throws AssertionImplementationError if error is unexpected
+ */
+const handleAssertionError = (error, assertion, isNegated) => {
+    if (error_js_1.AssertionError.isAssertionError(error)) {
+        if (isNegated) {
+            return;
+        }
+        throw error;
+    }
+    if (error_js_1.AssertionImplementationError.isAssertionImplementationError(error)) {
+        throw error;
+    }
+    throw new error_js_1.AssertionImplementationError(`Assertion ${assertion} threw a non-AssertionError`, { cause: error });
+};
+/**
+ * Throws a NegatedAssertionError when a negated assertion unexpectedly passes.
+ *
+ * @function
+ * @param assertion - The assertion that passed
+ * @param stackStartFn - Function for stack trace management
+ */
+const throwNegatedAssertionPassedError = (assertion, stackStartFn) => {
+    throw new error_js_1.NegatedAssertionError({
+        id: assertion.id,
+        message: `Expected assertion ${assertion} to fail (due to negation), but it passed`,
+        stackStartFn,
+    });
+};
+/**
+ * Processes negation keywords in the arguments and returns whether negation is
+ * requested along with arguments stripped of the leading negation (to enable
+ * assertion matching).
+ *
+ * @function
+ * @internal
+ */
+const maybeProcessNegation = (args) => {
+    let isNegated = false;
+    let processedArgs = args;
+    // note: args[1] should always be a string
+    if (args.length >= 2 && (0, guards_js_1.isString)(args[1])) {
+        const { cleanedPhrase, isNegated: detected } = detectNegation(args[1]);
+        if (detected) {
+            isNegated = true;
+            processedArgs = [args[0], cleanedPhrase, ...args.slice(2)];
+        }
+    }
+    return { isNegated, processedArgs };
+};
+/**
+ * Given some args, create a matrix of args based on the presence of the
+ * conjunction operator ("and").
+ *
+ * If no "and" is present, returns the original args wrapped in an array.
+ *
+ * @function
+ */
+const conjunctify = (args) => {
+    let argsMatrix = [args];
+    if (args.length >= 2) {
+        // partition args by the string "and"; there may be multiple "and"s
+        const andIndices = args
+            .map((arg, index) => (arg === 'and' ? index : -1))
+            .filter((index) => index !== -1);
+        if (andIndices.length > 0) {
+            const parts = [];
+            let lastIndex = 0;
+            for (const andIndex of andIndices) {
+                const partsArgs = lastIndex > 0
+                    ? [args[0], ...args.slice(lastIndex, andIndex)]
+                    : [...args.slice(lastIndex, andIndex)];
+                parts.push(partsArgs);
+                lastIndex = andIndex + 1;
+            }
+            const finalPartsArgs = [args[0], ...args.slice(lastIndex)];
+            parts.push(finalPartsArgs);
+            argsMatrix = parts;
+        }
+    }
+    return argsMatrix;
+};
+/**
+ * Generates all possible ways to rejoin args that were split on "and".
+ *
+ * This is used as a fallback when conjunctified attempts fail - we try
+ * different permutations of rejoining the split parts to handle assertions that
+ * use "and" as part of their phrase (e.g., "to be greater than X and less than
+ * Y").
+ *
+ * @function
+ * @param argsMatrix The matrix of split arguments
+ * @param originalArgs The original unsplit arguments
+ * @returns Array of permutations to try
+ * @internal
+ */
+const generateRejoinPermutations = (argsMatrix, originalArgs) => {
+    const permutations = [];
+    for (let i = 0; i < argsMatrix.length - 1; i++) {
+        const rejoinedParts = [];
+        // Add parts before the join point
+        for (let j = 0; j < i; j++) {
+            rejoinedParts.push([...argsMatrix[j]]);
+        }
+        // Join the two parts at the split point
+        const leftPart = argsMatrix[i];
+        const rightPart = argsMatrix[i + 1];
+        const joinedPart = [...leftPart, 'and', ...rightPart.slice(1)];
+        rejoinedParts.push(joinedPart);
+        // Add parts after the join point
+        for (let j = i + 2; j < argsMatrix.length; j++) {
+            rejoinedParts.push([...argsMatrix[j]]);
+        }
+        if (rejoinedParts.length === 1) {
+            permutations.push(rejoinedParts[0]);
+        }
+        else {
+            for (const part of rejoinedParts) {
+                permutations.push(part);
+            }
+        }
+    }
+    // Also try the original unsplit arguments as the final permutation
+    permutations.push(originalArgs);
+    return permutations;
+};
+/**
+ * Builds a phrase-keyed index for fast assertion dispatch.
+ *
+ * Maps phrase literals to the assertions that use them, enabling O(1) lookup
+ * instead of O(n) iteration over all assertions during dispatch.
+ *
+ * @function
+ * @param assertions - Array of assertions to index
+ * @returns Map from phrase string to array of assertions using that phrase
+ */
+const buildPhraseIndex = (assertions) => {
+    const index = new Map();
+    for (const assertion of assertions) {
+        const phrases = assertion.getIndexPhrases();
+        for (const phrase of phrases) {
+            const existing = index.get(phrase);
+            if (existing) {
+                existing.push(assertion);
+            }
+            else {
+                index.set(phrase, [assertion]);
+            }
+        }
+    }
+    return index;
+};
+/**
+ * Extracts the phrase from processed arguments for index lookup.
+ *
+ * Looks at position 1 (subject-first assertions) and position 0 (phrase-first).
+ * Returns the first string found, or undefined if no phrase is present.
+ *
+ * @function
+ * @param args - Processed arguments (after negation handling)
+ * @returns The phrase string if found, undefined otherwise
+ */
+const extractPhraseFromArgs = (args) => {
+    // Most common: subject at 0, phrase at 1
+    if (args.length > 1 && (0, guards_js_1.isString)(args[1])) {
+        return args[1];
+    }
+    // Less common: phrase at 0
+    if (args.length > 0 && (0, guards_js_1.isString)(args[0])) {
+        return args[0];
+    }
+    return undefined;
+};
+/**
+ * Gets candidate assertions for dispatch using phrase index lookup.
+ *
+ * Extracts the phrase from processed arguments and looks it up in the phrase
+ * index for O(1) candidate retrieval. Falls back to the full assertion list if
+ * no phrase is found or the phrase isn't indexed.
+ *
+ * @function
+ * @param processedArgs - Arguments after negation processing
+ * @param phraseIndex - Map from phrase strings to assertion arrays
+ * @param allAssertions - Complete assertion list for fallback
+ * @returns Array of candidate assertions to check
+ */
+const getCandidateAssertions = (processedArgs, phraseIndex, allAssertions) => {
+    const phrase = extractPhraseFromArgs(processedArgs);
+    return ((phrase !== undefined ? phraseIndex.get(phrase) : undefined) ??
+        allAssertions);
+};
+/**
+ * Throws an error indicating that no valid assertion could be found for the
+ * provided arguments.
+ *
+ * @function
+ * @param args The arguments that were passed to the expect function
+ * @internal
+ */
+const throwInvalidParametersError = (args) => {
+    const inspectedArgs = (0, util_1.inspect)(args, { depth: 1 });
+    debug('Invalid arguments. No assertion matched: %s', inspectedArgs);
+    throw new error_js_1.UnknownAssertionError(`Invalid arguments. No assertion matched: ${inspectedArgs}`, { args });
+};
+/**
+ * Detects if an assertion phrase starts with "not " and returns the cleaned
+ * phrase.
+ *
+ * @function
+ * @param phrase - The assertion phrase to check
+ * @returns Object with `isNegated` flag and `cleanedPhrase`
+ */
+const detectNegation = (phrase) => {
+    if (phrase.startsWith('not ')) {
+        return {
+            cleanedPhrase: phrase.substring(4), // Remove "not "
+            isNegated: true,
+        };
+    }
+    return {
+        cleanedPhrase: phrase,
+        isNegated: false,
+    };
+};
+/**
+ * {@inheritDoc FailFn}
+ *
+ * @function
+ */
+const fail = (reason) => {
+    throw new error_js_1.FailAssertionError({ message: reason });
+};
+/**
+ * Used by a {@link UseFn} to create base properties of {@link Expect} or
+ * {@link ExpectAsync}.
+ */
+function createBaseExpect(syncAssertions, asyncAssertions, type) {
+    const assertions = type === 'sync' ? syncAssertions : asyncAssertions;
+    return {
+        assertions,
+        createAssertion: create_js_1.createAssertion,
+        createAsyncAssertion: create_js_1.createAsyncAssertion,
+        fail,
+        use: (0, use_js_1.createUse)(syncAssertions, asyncAssertions),
+    };
+}
+//# sourceMappingURL=expect.js.map

package/dist/expect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect.js","sourceRoot":"","sources":["../src/expect.ts"],"names":[],"mappings":"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"}