eslint-plugin-mocha/ast/find-mocha-variable-calls.js

Eslint rules for mocha.

import { reduceWithArgs } from '../list.js';
import { reformatLastPathSegmentWithCallExpressions } from '../mocha/name-details.js';
import { isSamePath } from '../mocha/path.js';
import { resolveAliasedReferences } from './alias-references.js';
import { findGlobalReferencesByName } from './find-global-references.js';
import { findImportReferencesByName } from './find-import-references.js';
import { isConstantPath } from './member-expression.js';
import { isCallExpression, isMemberExpression } from './node-types.js';
function isCallExpressionReference(reference) {
    return reference.node.type === 'CallExpression';
}
function addReferenceToResults(results, matchingReference) {
    return [...results, matchingReference];
}
function getCallDetails(reference) {
    let { node } = reference;
    let count = 0;
    while (node.parent.type === 'CallExpression') {
        node = node.parent;
        count += 1;
    }
    return { node, amountOfCallExpressions: count };
}
function shouldProcessReference(results, reference) {
    if (isCallExpressionReference(reference)) {
        const { node: newNode, amountOfCallExpressions } = getCallDetails(reference);
        return addReferenceToResults(results, {
            ...reference,
            node: newNode,
            resolvedPath: reformatLastPathSegmentWithCallExpressions(reference.resolvedPath, amountOfCallExpressions)
        });
    }
    return results;
}
function findMatchingNameDetails(pathToMatch, names) {
    for (const nameDetails of names) {
        if (isSamePath(pathToMatch, nameDetails.normalizedPath)) {
            return nameDetails;
        }
    }
    return null;
}
// eslint-disable-next-line max-statements -- needs to be refactored
function shouldAddReferenceToResults(results, reference, names) {
    const nameDetails = findMatchingNameDetails(reference.resolvedPath, names);
    if (nameDetails === null) {
        return results;
    }
    const { callee } = reference.node;
    if (nameDetails.config !== null && isMemberExpression(callee) && isCallExpression(callee.object)) {
        const resolvedPath2 = reference.resolvedPath.slice(0, -1);
        const path2 = reference.path.slice(0, -1);
        const nameDetails2 = findMatchingNameDetails(resolvedPath2, names);
        if (nameDetails2 !== null) {
            return [
                ...results,
                { ...reference, nameDetails, name: reference.resolvedPath.join('.') },
                {
                    ...reference,
                    node: callee.object,
                    name: path2.join('.'),
                    path: path2,
                    resolvedPath: resolvedPath2,
                    nameDetails: nameDetails2
                }
            ];
        }
    }
    return [...results, { ...reference, nameDetails, name: reference.resolvedPath.join('.') }];
}
function isResultWithConstantPath(result) {
    return isConstantPath(result.path);
}
export function findMochaVariableCalls(context, names, interfaceToUse) {
    const { sourceCode } = context;
    const references = interfaceToUse === 'exports'
        ? findImportReferencesByName(context, names, 'mocha')
        : findGlobalReferencesByName(context, names);
    const resolvedReferences = resolveAliasedReferences(sourceCode, references);
    const constantResolvedReferences = reduceWithArgs(resolvedReferences, shouldProcessReference, []);
    const filteredReferences = constantResolvedReferences.filter(isResultWithConstantPath);
    return reduceWithArgs(filteredReferences, shouldAddReferenceToResults, [], names);
}
//# sourceMappingURL=find-mocha-variable-calls.js.map