@syncerauk/test-rules 1.0.4 → 1.0.5

package/README.md

@@ -56,7 +56,8 @@ Both in the repo's `scripts/test-rules/`:
   key, `"key": null` when the file itself is the map). The defaults are `CONFIG_DEFAULTS` in the
   script.
 - `listed.json`: the breaches the repo had on the day the check arrived. Written once by
-  `test-rules --init`.
+  `test-rules --init`. An optional `moved` map, `{ "<new test file>": "<old test file>" }`,
+  says where a split or a rename took a listed file.
 
 ## The list only shrinks
 
@@ -64,11 +65,18 @@ Both in the repo's `scripts/test-rules/`:
 - An entry whose breach is gone is stale and fails until its line is deleted.
 - Against a base, an entry the base's list does not hold fails. The base is `--base <ref>`,
   else `origin/main` when it resolves.
+- A split or a rename carries its listed breaches: the new file's entry passes when `moved`
+  names the old file, the base listed the same rule on it, and the old file is no longer a test
+  file. A `moved` line is never stale and never a breach; delete it whenever you like.
 
 A repo starts with `"fail": false`: breaches are printed and the exit is 0. One line turns it on.
 
 ## Versions
 
+- **1.0.5** — A split or rename carries its listed breaches: `listed.json` may hold
+  `"moved": { "<new test file>": "<old test file>" }`, and a new file's entry is not
+  `list:grew` when the base listed the same rule on the old file and the old file is gone.
+  Nothing changes for a repo that does not set it.
 - **1.0.4** — `style_contract`: a repo may name one test that reads its stylesheets (`.css`,
   `.scss`), the way wording is read once from the wording list. Those files are not a
   `T4:source-text` breach in that test, and only in that test. Nothing changes for a repo that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncerauk/test-rules",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "The static check of Syncera's test-writing rules (T1, T4, T6 and the line limit of R7). One file, no dependency. Published to npm by the orchestrator's publish-test-rules workflow; each repo pins an exact version.",
   "type": "module",
   "license": "UNLICENSED",

package/test-rules.mjs

@@ -16,7 +16,9 @@
 //
 // Per repo, two files:
 //   scripts/test-rules/config.json   what differs between repos (CONFIG_DEFAULTS below)
-//   scripts/test-rules/listed.json   { v: 1, entries: { "<test file>": ["<rule id>", …] } }
+//   scripts/test-rules/listed.json   { v: 1, entries: { "<test file>": ["<rule id>", …] },
+//                                      moved: { "<new test file>": "<old test file>" } }
+// `moved` is optional: it says where a split or a rename took a listed file (1.0.5).
 //
 // The list only shrinks. A breach on the list passes; a breach off the list fails; an entry
 // whose breach is gone is `stale` and fails until its line is deleted; with a base, an entry the
@@ -24,6 +26,10 @@
 // lines than at the base fails (`T1:hub`). The base is `--base <ref>`, else origin/main when it
 // resolves (the merge base with HEAD is what is read); `--no-base` skips those two checks. The
 // base having no list at all is the one change that may add it (`--init` writes it once).
+// A split or a rename carries its listed breaches: an entry the base does not hold is not
+// `list:grew` when `moved` names its old file, the base listed that same rule on the old file,
+// and the old file is no longer a test file. A `moved` line is never stale and never a breach;
+// it may be deleted at any time.
 // `"fail": false` in the config is report only: everything is printed, the exit is 0.
 //
 // The rules (RULES below) and how each is seen:
@@ -349,9 +355,12 @@ export function breachesOf({ files, config, register = null, tracked = null }) {
  * The verdict over the breaches and the list. `listed`: the head's entries ({ file: [rule] }).
  * `base`: null (no base read), or { listed: the base's entries or null when the base has no
  * list, lines: { file: its line count at the base } }.
+ * `moved`: { new file: old file } from the head's list. `present`: a Set of the head's test
+ * files, or null (then nothing is carried). An entry the base does not hold is carried, not
+ * `list:grew`, when its old file is gone and the base listed the same rule on it.
  * → { breaches (off the list, plus T1:hub and list:grew), listed (count on the list), stale }.
  */
-export function verdict({ all, listed = {}, base = null, lineCounts = {} }) {
+export function verdict({ all, listed = {}, base = null, lineCounts = {}, moved = {}, present = null }) {
   const on = (file, rule) => (listed[file] ?? []).includes(rule) && !NEVER_LISTED.includes(rule);
   const breaches = all.filter((b) => !on(b.file, b.rule));
   const hits = all.filter((b) => on(b.file, b.rule));
@@ -360,10 +369,14 @@ export function verdict({ all, listed = {}, base = null, lineCounts = {} }) {
   for (const file of Object.keys(listed).sort()) {
     for (const rule of [...listed[file]].sort()) if (!found.has(`${file}\n${rule}`)) stale.push({ file, rule });
   }
+  const carried = (file, rule) => {
+    const old = Object.hasOwn(moved, file) ? moved[file] : null;
+    return typeof old === 'string' && present !== null && !present.has(old) && (base.listed?.[old] ?? []).includes(rule);
+  };
   if (base) {
     for (const file of Object.keys(listed).sort()) {
       for (const rule of [...listed[file]].sort()) {
-        if (base.listed && !(base.listed[file] ?? []).includes(rule)) breaches.push({ file, rule: 'list:grew', line: 1, say: `${rule}: ${RULES['list:grew']}` });
+        if (base.listed && !(base.listed[file] ?? []).includes(rule) && !carried(file, rule)) breaches.push({ file, rule: 'list:grew', line: 1, say: `${rule}: ${RULES['list:grew']}` });
       }
       const was = base.lines?.[file];
       if (listed[file].includes('R7:lines') && Number.isFinite(was) && lineCounts[file] > was) {
@@ -462,6 +475,15 @@ export function entriesOf(obj, where) {
   if (!ok) throw fail(EXIT.FAILED, `${where}: must be { "v": ${VERSION}, "entries": { "<test file>": ["<rule id>", …] } }`);
   return e;
 }
+/** The optional `moved` map of a list: { "<new test file>": "<old test file>" }, or {} when absent. */
+export function movedOf(obj, where) {
+  if (obj?.moved === undefined) return {};
+  const m = obj.moved;
+  const ok = m && typeof m === 'object' && !Array.isArray(m)
+    && Object.entries(m).every(([to, from]) => typeof from === 'string' && from.length > 0 && from !== to);
+  if (!ok) throw fail(EXIT.FAILED, `${where}: "moved" must be { "<new test file>": "<old test file>", … }, each old file named and not the new one`);
+  return m;
+}
 
 export function main(argv = [], { log = console.log, error = console.error } = {}) {
   try {
@@ -486,7 +508,9 @@ export function main(argv = [], { log = console.log, error = console.error } = {
       return EXIT.CLEAN;
     }
 
-    const listed = existsSync(join(dir, LISTED_FILE)) ? entriesOf(readJson(dir, LISTED_FILE), LISTED_FILE) : {};
+    const listedJson = existsSync(join(dir, LISTED_FILE)) ? readJson(dir, LISTED_FILE) : null;
+    const listed = listedJson ? entriesOf(listedJson, LISTED_FILE) : {};
+    const moved = listedJson ? movedOf(listedJson, LISTED_FILE) : {};
     let base = null;
     let baseNote = 'no base';
     if (!opts.noBase) {
@@ -512,7 +536,7 @@ export function main(argv = [], { log = console.log, error = console.error } = {
       } else baseNote = `no base (${ref} does not resolve)`;
     }
     const lineCounts = Object.fromEntries(files.map((f) => [f.path, countLines(f.text)]));
-    const v = verdict({ all, listed, base, lineCounts });
+    const v = verdict({ all, listed, base, lineCounts, moved, present: new Set(testPaths) });
 
     if (opts.list) {
       log(JSON.stringify({ v: VERSION, breaches: v.breaches, listed: v.listed, stale: v.stale }));