Method evaluateRuleIf

src/utils.ts:229–336

(ruleIf: string | undefined, envs: {[key: string]: string})

    }

    static evaluateRuleIf (ruleIf: string | undefined, envs: {[key: string]: string}): boolean {
        if (ruleIf === undefined) return true;
        assert(!/\$\{\w+\}/.test(ruleIf), chalk`rules:rule if invalid expression syntax: {blueBright ${ruleIf}}\nuse {green $VAR} not {red \${VAR\}} in rules:if`);
        let evalStr = ruleIf;

        const flagsToBinary = (flags: string): number => {
            let binary = 0;
            if (flags.includes("i")) {
                binary |= RE2JS.CASE_INSENSITIVE;
            }
            if (flags.includes("s")) {
                binary |= RE2JS.DOTALL;
            }
            if (flags.includes("m")) {
                binary |= RE2JS.MULTILINE;
            }
            return binary;
        };

        // Expand all variables
        evalStr = this.expandTextWith(evalStr, {
            unescape: JSON.stringify("$"),
            variable: (name) => JSON.stringify(envs[name] ?? null).replaceAll("\\\\", "\\"),
        });
        const expandedEvalStr = evalStr;

        // Scenario when RHS is a <regex>
        // https://regexr.com/85sjo
        const pattern1 = /\s*(?<operator>(?:=~)|(?:!~))\s*\/(?<rhs>.*?[^\\])\/(?<flags>[igmsuy]*)(\s|$|\))/g;
        evalStr = evalStr.replaceAll(pattern1, (_, operator, rhs, flags, remainingTokens) => {
            let _operator;
            switch (operator) {
                case "=~":
                    _operator = "!=";
                    break;
                case "!~":
                    _operator = "==";
                    break;
                default:
                    throw operator;
            }
            const _rhs = JSON.stringify(rhs); // JSON.stringify for escaping `"`
            const containsNonEscapedSlash = /(?<!\\)\//.test(_rhs);
            const assertMsg = [
                "Error attempting to evaluate the following rules:",
                "  rules:",
                `    - if: '${expandedEvalStr}'`,
                "as rhs contains unescaped quote",
            ];
            assert(!containsNonEscapedSlash, assertMsg.join("\n"));
            const flagsBinary = flagsToBinary(flags);
            return `.matchRE2JS(RE2JS.compile(${_rhs}, ${flagsBinary})) ${_operator} null${remainingTokens}`;
        });

        // Scenario when RHS is surrounded by single/double-quotes
        // https://regexr.com/85t0g
        const pattern2 = /\s*(?<operator>=~|!~)\s*(["'])(?<rhs>(?:\\.|[^\\])*?)\2/g;
        evalStr = evalStr.replaceAll(pattern2, (_, operator, __, rhs) => {