@t09tanaka/test-gates 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.5.2
+
+### Fixed
+
+- `selfcheck --jobs` really no longer keeps every other control apart because of the word `require` in a string, a template, a comment or a regular expression. 0.5.1 fixed the reason given for a spec, but the plan of which controls run on their own still looked at the whole text.
+
+## 0.5.1
+
+### Fixed
+
+- `selfcheck --jobs` no longer keeps every other control apart because the word `require` appears inside a string, a template, a comment or a regular expression (`'sslmode=require'`, `// pass it to require`). Only code is looked at now. Handing `require` on under another name (`const r = require`) still counts as loading a module whose name is computed.
+
 ## 0.5.0
 
 This release makes the gates quicker to check in CI: `test-gates mutation --shard <index>/<total>` splits the mutation run over parallel jobs, and `selfcheck --jobs` runs more controls side by side. Nothing changes for a run without the new option:

package/dist/cli.js

@@ -5447,6 +5447,9 @@ var REACHES = [
 ];
 var COMPUTED_LOAD = /(?:require|import)\((?!['"])|\brequire(?!\(|\.resolve\b|[\w$])|\bimport\.meta\.glob\b/;
 var COMPUTED = "loads a module whose name is computed";
+function loadsComputed(source) {
+  return COMPUTED_LOAD.test(withoutLiterals(source).replace(/\s/g, ""));
+}
 var STRING = /(^|[:,([={?+&|;])(\s*)(['"])((?:\\.|(?!\3)[^\\\n])*)\3(?=\s*(?:[,}\]);:+?&|]|$))/gm;
 function withoutStrings(source) {
   return source.replace(
@@ -5458,6 +5461,70 @@ function withoutStrings(source) {
     )
   );
 }
+var BEFORE_REGEX = /(?:^|[(,=:[!&|?{};+\-*%<>~^]|\b(?:return|typeof|case|in|of|void|delete|throw|new|yield|await))\s*$/;
+var COMMENT_OR_STRING = /\/\/[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|(['"])(?:\\.|(?!\1)[^\\\n])*\1?/y;
+var REGEX = /\/(?:\\.|\[(?:\\.|[^\]\\\n])*\]?|[^/\\\n[])*\/?/y;
+var TEMPLATE_TEXT = /(?:\\[\s\S]|[^`\\$]|\$(?!\{))*/y;
+function withoutLiterals(source) {
+  let out = "";
+  let i = 0;
+  const blank = (text) => text.replace(/[^\n]/g, " ");
+  const enclosed = (literal) => {
+    const closed = literal.length > 1 && literal.endsWith(literal.charAt(0));
+    return literal.charAt(0) + blank(literal.slice(1, closed ? -1 : void 0)) + (closed ? literal.charAt(0) : "");
+  };
+  const take = (pattern) => {
+    pattern.lastIndex = i;
+    const found = pattern.exec(source)?.[0] ?? null;
+    if (found !== null) {
+      i += found.length;
+    }
+    return found;
+  };
+  const code = (inBraces) => {
+    while (i < source.length) {
+      const c = source[i];
+      const literal = take(COMMENT_OR_STRING);
+      if (literal !== null) {
+        out += literal.startsWith("/") ? blank(literal) : enclosed(literal);
+      } else if (c === "/" && BEFORE_REGEX.test(out)) {
+        out += enclosed(take(REGEX));
+      } else if (c === "`") {
+        i += 1;
+        out += "`";
+        template();
+      } else if (c === "}" && inBraces) {
+        return;
+      } else if (c === "{" && inBraces) {
+        braces("{");
+      } else {
+        out += c;
+        i += 1;
+      }
+    }
+  };
+  const braces = (open) => {
+    i += open.length;
+    out += open;
+    code(true);
+    if (i < source.length) {
+      i += 1;
+      out += "}";
+    }
+  };
+  const template = () => {
+    out += blank(take(TEMPLATE_TEXT));
+    if (source.startsWith("${", i)) {
+      braces("${");
+      template();
+    } else if (i < source.length) {
+      i += 1;
+      out += "`";
+    }
+  };
+  code(false);
+  return out;
+}
 var PURE_BUILTINS = [
   "assert",
   "assert/strict",
@@ -5473,13 +5540,12 @@ var PURE_BUILTINS = [
 ];
 var RUNNER_PACKAGES = ["vitest", "@jest/globals"];
 function reachesOutside(file, trusted) {
-  const dense = file.source.replace(/\s/g, "");
   const code = withoutStrings(file.source).replace(/\s/g, "");
   const mark = REACHES.find((text) => code.includes(text));
   if (mark !== void 0) {
     return `uses ${mark.replace(/[.?[(:]+$/, "")}`;
   }
-  if (COMPUTED_LOAD.test(dense)) {
+  if (loadsComputed(file.source)) {
     return COMPUTED;
   }
   for (const { specifier, builtin } of file.imports) {
@@ -5519,7 +5585,7 @@ function jobsPlan(input) {
     const reaches = loaded.flatMap((file) => {
       const reach = reachesOutside(file, input.trusted);
       const said = reach === null ? [] : [`${file.path} ${reach}`];
-      if (!COMPUTED_LOAD.test(file.source.replace(/\s/g, ""))) {
+      if (!loadsComputed(file.source)) {
         return said;
       }
       computed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t09tanaka/test-gates",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Test gates for the code that must not be wrong: per-file 100% coverage as the floor, mutation testing with a per-mutant allow list as the real check.",
   "author": "t09tanaka",
   "license": "MIT",