@mmisty/cypress-grep/utils/regexp.js

Filters tests by tags/title using substring or regular expressions (can find dynamic tags)

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.selectionTestGrep = exports.convertOneGroup = exports.replaceParenthesisGroups = exports.simplifyParentheses = void 0;
const simplifyParentheses = (input) => {
    // Replace deeply nested parentheses with a single group
    let simplified = input;
    while (/\(\(([^()]+)\)\)/.test(simplified)) {
        simplified = simplified.replace(/\(\(([^()]+)\)\)/, '($1)');
    }
    return simplified.replace(/&\(\.\*\)/g, '');
};
exports.simplifyParentheses = simplifyParentheses;
/**
 * replace all parenthesis groups with placeholder
 * @param input
 * @param replacements
 * @param num
 */
const replaceParenthesisGroups = (input, replacements, num = 1) => {
    let replaced = (0, exports.simplifyParentheses)(input);
    const groupsNeg = input.match(/!\(([^()]*)\)/);
    const groups = input.match(/\(([^()]*)\)/);
    if (!groupsNeg && !groups) {
        return replaced;
    }
    const replaceExpression = (expression, group, inverse) => {
        const mapName = `##R${num}##`;
        replacements.push({ mapName, exp: group, inverse, order: num });
        replaced = replaced.replace(expression, mapName);
        return (0, exports.replaceParenthesisGroups)(replaced, replacements, num + 1);
    };
    if (groupsNeg) {
        return replaceExpression(groupsNeg[0], groupsNeg[1], true);
    }
    else if (groups) {
        if (replaced === '(.*)') {
            return '';
        }
        return replaceExpression(groups[0], groups[1], false);
    }
    return replaced;
};
exports.replaceParenthesisGroups = replaceParenthesisGroups;
/**
 * no parenthesis in the group
 * @param exp
 * @param inverse
 */
const convertOneGroup = (exp, inverse) => {
    const reg = exp
        .split('/')
        .map(t => (t.startsWith('!') ? t.replace(/^!(.*)/, '^(?!.*$1.*)') : t))
        .map(t => t.indexOf('&') !== -1
        ? `${t
            .split('&')
            .map(nd => (nd.startsWith('!') ? nd.replace(/^!(.*)/, '^(?!.*$1.*)') : nd.replace(/^(.*)/, '(?=.*$1)')))
            .join('+')}+`
        : t)
        .join('|');
    const res = reg.indexOf('|') !== -1 ? `(${reg})` : reg;
    return inverse ? `^(?!.*${res}.*)` : `${res}`;
};
exports.convertOneGroup = convertOneGroup;
const selectionTestGrep = (str) => {
    if (str.startsWith('=')) {
        // expressions like '=/hello$/i'
        const beg = str.slice(1);
        const endOfExpr = beg.lastIndexOf('/');
        const flags = endOfExpr < beg.length - 1 ? beg.slice(endOfExpr + 1) : '';
        const expr = beg.slice(beg.indexOf('/') + 1, endOfExpr);
        return new RegExp(expr, flags);
    }
    const leftParenth = '##LP##';
    const rightParenth = '##RP##';
    const replacements = [];
    str = str.replace(/\\\(/g, leftParenth).replace(/\\\)/g, rightParenth);
    const replacedString = (0, exports.replaceParenthesisGroups)(str, replacements);
    let convertedString = (0, exports.convertOneGroup)(replacedString, false);
    const groups = replacements.map(t => (Object.assign(Object.assign({}, t), { reg: (0, exports.convertOneGroup)(t.exp, t.inverse) })));
    // last group should be converted first
    groups
        .sort((a, b) => (a.order > b.order ? -1 : 1))
        .forEach(r => {
        convertedString = convertedString.replace(r.mapName, r.reg);
    });
    convertedString = convertedString
        .replace(/\.\*\.\*/g, '.*')
        .replace(new RegExp(leftParenth, 'g'), '\\(')
        .replace(new RegExp(rightParenth, 'g'), '\\)');
    return new RegExp(`${convertedString}.*`, 'i');
};
exports.selectionTestGrep = selectionTestGrep;