refactor(rules:if): remove dead _evaluateRuleIf and simplify _nodeToAtom

- Delete _evaluateRuleIf: its regex-substitution logic (pattern1/pattern2,
  null.matchRE2JS replacements, re-expansion) was entirely unreachable when
  called from the jsep walk, which handles =~/!~/&&/|| before falling through
- Inline a direct eval in the walk fallback (for ==, !=, comparisons, bare
  literals), replacing the _evaluateRuleIf call
- Drop unused envs parameter from _nodeToAtom and remove commented-out block

Author: ticapix

src/utils.ts

@@ -18,7 +18,7 @@ import {AxiosRequestConfig} from "axios";
 import path from "node:path";
 import {Argv} from "./argv.js";
 
-jsep.plugins.register(jsepRegex);   // /pattern/flags literals
+jsep.plugins.register(jsepRegex); // /pattern/flags literals
 jsep.addBinaryOp("=~", 10); // regex match operator
 jsep.addBinaryOp("!~", 10); // regex non-match operator
 
@@ -222,20 +222,13 @@ export class Utils {
     // Reconstruct the source string for an atomic (non-logical) jsep node.
     // Identifiers keep their name ($VAR), literals use their raw form so that
     // strings retain quotes and regexes retain slashes and flags.
-    private static _nodeToAtom (node: jsep.Expression, envs: {[key: string]: string}): string {
+    private static _nodeToAtom (node: jsep.Expression): string {
         switch (node.type) {
-            case "Identifier": {
-                const n = node as jsep.Identifier;
-                return n.name;
-                // return this.expandTextWith(n.name, {
-                //     unescape: JSON.stringify("$"),
-                //     variable: (name) => JSON.stringify(envs[name] ?? null).replaceAll("\\\\", "\\"),
-                // });
-            }
+            case "Identifier": return (node as jsep.Identifier).name;
             case "Literal": return (node as jsep.Literal).raw;
             case "BinaryExpression": {
                 const n = node as jsep.BinaryExpression;
-                return `${Utils._nodeToAtom(n.left, envs)} ${n.operator} ${Utils._nodeToAtom(n.right, envs)}`;
+                return `${Utils._nodeToAtom(n.left)} ${n.operator} ${Utils._nodeToAtom(n.right)}`;
             }
             default: return "";
         }
@@ -317,7 +310,7 @@ export class Utils {
                         const assertMsg = [
                             "Error attempting to evaluate the following rules:",
                             "  rules:",
-                            `    - if: '${Utils._nodeToAtom(node, envs)}'`,
+                            `    - if: '${Utils._nodeToAtom(node)}'`,
                             "as",
                             "```javascript",
                             `${evalStr}`,
@@ -328,10 +321,24 @@ export class Utils {
                     return Boolean(res);
                 }
             }
-            // assert (node.type === "Literal", `not a Literal: ${JSON.stringify(node)}`)
-            const res = Utils._evaluateRuleIf(Utils._nodeToAtom(node, envs), envs);
-            // console.log(`${JSON.stringify(node)} -> ${res}`)
-            return res;
+            const atom = Utils._nodeToAtom(node);
+            let res;
+            try {
+                (globalThis as any).RE2JS = RE2JS;
+                res = (0, eval)(atom);
+                delete (globalThis as any).RE2JS;
+            } catch {
+                assert(false, [
+                    "Error attempting to evaluate the following rules:",
+                    "  rules:",
+                    `    - if: '${ruleIf}'`,
+                    "as",
+                    "```javascript",
+                    `${atom}`,
+                    "```",
+                ].join("\n"));
+            }
+            return Boolean(res);
         };
 
         let ast;
@@ -352,113 +359,6 @@ export class Utils {
         return walk(ast!);
     }
 
-    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;
-        };
-
-        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 = "!="; // Matches are found (!= null)
-                    break;
-                case "!~":
-                    _operator = "=="; // Matches are not found (== null)
-                    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) => {
-            let _operator;
-            switch (operator) {
-                case "=~":
-                    _operator = "!="; // Matches are found (!= null)
-                    break;
-                case "!~":
-                    _operator = "=="; // Matches are not found (== null)
-                    break;
-                default:
-                    throw operator;
-            }
-
-            const assertMsg = [
-                "RHS (${rhs}) must be a regex pattern. Do not rely on this behavior!",
-                "Refer to https://docs.gitlab.com/ee/ci/jobs/job_rules.html#unexpected-behavior-from-regular-expression-matching-with- for more info...",
-            ];
-            assert((/\/(.*)\/(\w*)/.test(rhs)), assertMsg.join("\n"));
-
-            const regex = /\/(?<pattern>.*)\/(?<flags>[igmsuy]*)/;
-            const _rhs = rhs.replace(regex, (_: string, pattern: string, flags: string) => {
-                const flagsBinary = flagsToBinary(flags);
-                return `RE2JS.compile("${pattern}", ${flagsBinary})`;
-            });
-            return `.matchRE2JS(${_rhs}) ${_operator} null`;
-        });
-
-        evalStr = evalStr.replaceAll(/null.matchRE2JS\(.+?\)\s*!=\s*null/g, "false");
-        evalStr = evalStr.replaceAll(/null.matchRE2JS\(.+?\)\s*==\s*null/g, "true");
-
-        evalStr = evalStr.trim();
-
-        let res;
-        try {
-            (globalThis as any).RE2JS = RE2JS;
-            res = (0, eval)(evalStr); // indirect eval
-            delete (globalThis as any).RE2JS;
-        } catch {
-            const assertMsg = [
-                "Error attempting to evaluate the following rules:",
-                "  rules:",
-                `    - if: '${expandedEvalStr}'`,
-                "as",
-                "```javascript",
-                `${evalStr}`,
-                "```",
-            ];
-            assert(false, assertMsg.join("\n"));
-        }
-        return Boolean(res);
-    }
 
     static evaluateRuleExist (cwd: string, ruleExists: string[] | {paths: string[]} | undefined): boolean {
         if (ruleExists === undefined) return true;