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

Eslint rules for mocha.

import { reduceWithArgs } from "../list.js";
import { getAllNames } from "../mocha/all-name-details.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 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 (!isCallExpression(reference.node)) {
        return results;
    }
    const callReference = {
        ...reference,
        node: reference.node
    };
    const { node: newNode, amountOfCallExpressions } = getCallDetails(callReference);
    return addReferenceToResults(results, {
        ...callReference,
        node: newNode,
        resolvedPath: reformatLastPathSegmentWithCallExpressions(reference.resolvedPath, amountOfCallExpressions)
    });
}
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);
}
function splitCustomNamesByInterface(customNames) {
    return {
        require: customNames.filter(function (nameDetails) {
            return nameDetails.interface === 'require';
        }),
        globals: customNames.filter(function (nameDetails) {
            return nameDetails.interface !== 'require';
        })
    };
}
export function findMochaVariableCalls(context, customNames, interfaceToUse, includeAllInterfaces) {
    const { sourceCode } = context;
    const builtinNames = getAllNames([], interfaceToUse, includeAllInterfaces);
    const builtinReferences = interfaceToUse === 'require'
        ? findImportReferencesByName(context, builtinNames, 'mocha')
        : findGlobalReferencesByName(context, builtinNames);
    const customNamesByInterface = splitCustomNamesByInterface(customNames);
    const customRequireReferences = findImportReferencesByName(context, customNamesByInterface.require, null);
    const customGlobalReferences = findGlobalReferencesByName(context, customNamesByInterface.globals);
    const resolvedReferences = resolveAliasedReferences(sourceCode, [
        ...builtinReferences,
        ...customRequireReferences,
        ...customGlobalReferences
    ]);
    const constantResolvedReferences = reduceWithArgs(resolvedReferences, shouldProcessReference, []);
    const filteredReferences = constantResolvedReferences.filter(isResultWithConstantPath);
    return reduceWithArgs(filteredReferences, shouldAddReferenceToResults, [], [...builtinNames, ...customNames]);
}
//# sourceMappingURL=find-mocha-variable-calls.js.map