@avi2dg/checks 0.16.0 → 0.18.0

package/scripts/shell-command.ts

@@ -0,0 +1,74 @@
+export type Command = readonly string[];
+
+type Span = {
+  readonly text: string;
+  readonly end: number;
+};
+
+const VARIABLE = /^\$(?:[A-Za-z_][A-Za-z0-9_]*|\{[A-Za-z_][A-Za-z0-9_]*\})/;
+const UNPLAIN = new Set(["|", "&", ";", "<", ">", "(", ")", "`", "\\", "#", "\n"]);
+
+function variable(line: string, from: number): Span | undefined {
+  const match = VARIABLE.exec(line.slice(from));
+  return match === null ? undefined : { text: match[0], end: from + match[0].length };
+}
+
+function singleQuoted(line: string, open: number): Span | undefined {
+  const close = line.indexOf("'", open + 1);
+  return close === -1 ? undefined : { text: line.slice(open + 1, close), end: close + 1 };
+}
+
+function doubleQuoted(line: string, open: number): Span | undefined {
+  let text = "";
+  let index = open + 1;
+  while (line.charAt(index) !== '"') {
+    const inner = line.charAt(index);
+    if (inner === "" || inner === "\\" || inner === "`") return undefined;
+    const part = inner === "$" ? variable(line, index) : { text: inner, end: index + 1 };
+    if (part === undefined) return undefined;
+    text += part.text;
+    index = part.end;
+  }
+  return { text, end: index + 1 };
+}
+
+function wordPart(line: string, index: number): Span | undefined {
+  const char = line.charAt(index);
+  if (char === "'") return singleQuoted(line, index);
+  if (char === '"') return doubleQuoted(line, index);
+  if (char === "$") return variable(line, index);
+  return UNPLAIN.has(char) ? undefined : { text: char, end: index + 1 };
+}
+
+// A script counts only when it is one line of plain words: any shell control, redirection or
+// substitution can run the gate without its failure failing the step.
+export function plainCommand(script: string): Command | undefined {
+  const line = script.trim();
+  const words: string[] = [];
+  let word: string | undefined;
+  let index = 0;
+  while (index < line.length) {
+    const char = line.charAt(index);
+    if (char === " " || char === "\t") {
+      if (word !== undefined) words.push(word);
+      word = undefined;
+      index += 1;
+    } else {
+      const part = wordPart(line, index);
+      if (part === undefined) return undefined;
+      word = (word ?? "") + part.text;
+      index = part.end;
+    }
+  }
+  if (word !== undefined) words.push(word);
+  return words.length === 0 ? undefined : words;
+}
+
+export function invokes(command: Command | undefined, gate: Command): boolean {
+  return command !== undefined && gate.length <= command.length && gate.every((word, index) => command[index] === word);
+}
+
+export function mentions(script: string, gate: Command): boolean {
+  const tokens = script.split(/[\s|&;<>()`]+/);
+  return tokens.some((_, start) => invokes(tokens.slice(start), gate));
+}

package/scripts/size-budget.ts

@@ -1,11 +1,14 @@
 #!/usr/bin/env bun
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { changedPaths, collect, git, pathsAt, rangeEnds, type Change } from "./git.ts";
-import { runMain, Usage } from "./main.ts";
-import { readQuality, renderJson } from "./quality-file.ts";
+import { runMain } from "./main.ts";
+import { renderJson } from "./quality-file.ts";
+import { rangeGateInputs } from "./range-gate.ts";
 import {
   budgetOf,
   budgetsOf,
+  diagnosticCode,
+  qualifiedName,
   SIZE_DEFAULTS,
   SIZE_RULES,
   TESTS_DIRECTORY,
@@ -68,16 +71,17 @@ const decodeReport = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Str
 
 function rulesOf(budget: Budget): Record<string, unknown> {
   return Object.fromEntries(
-    SIZE_RULES.map(({ key, rule, options }) => {
-      const max = budget[key];
-      return [rule, max === undefined ? "off" : ["error", { max, ...options }]];
+    SIZE_RULES.map((entry) => {
+      const max = budget[entry.key];
+      return [qualifiedName(entry), max === undefined ? "off" : ["error", { max, ...entry.options }]];
     }),
   );
 }
 
-function sizeConfig({ production, tests }: Budgets): unknown {
+function sizeConfig({ production, tests }: Budgets, plugin: string): unknown {
   return {
     plugins: [],
+    jsPlugins: [plugin],
     categories: { correctness: "off" },
     rules: rulesOf(production),
     overrides: [{ files: [`${TESTS_DIRECTORY}/**`], rules: rulesOf(tests) }],
@@ -116,7 +120,7 @@ const materializeBase = Effect.fn("materializeBase")(function* (root: string, ba
 
 const siteOf = (budgets: Budgets) =>
   Effect.fn("siteOf")(function* ({ code, message, filename, labels }: typeof Diagnostic.Type) {
-    const rule = SIZE_RULES.find((candidate) => code === `eslint(${candidate.rule})`);
+    const rule = SIZE_RULES.find((candidate) => code === diagnosticCode(candidate));
     if (rule === undefined) return [];
     const measured = rule.measured.exec(message)?.[1];
     const max = budgetOf(budgets, filename)[rule.key];
@@ -135,11 +139,11 @@ const siteOf = (budgets: Budgets) =>
     ];
   });
 
-const measure = Effect.fn("measure")(function* (tree: string, budgets: Budgets) {
+const measure = Effect.fn("measure")(function* (tree: string, budgets: Budgets, plugin: string) {
   const fs = yield* FileSystem.FileSystem;
   if (!(yield* fs.exists(tree))) return [];
   // oxlint reads an override's glob from the directory of the config that holds it, so the config sits in the tree.
-  yield* fs.writeFileString((yield* Path.Path).join(tree, CONFIG), renderJson(sizeConfig(budgets)));
+  yield* fs.writeFileString((yield* Path.Path).join(tree, CONFIG), renderJson(sizeConfig(budgets, plugin)));
 
   const { stdout, stderr, exitCode } = yield* collect("oxlint", ["-c", CONFIG, "-f", "json", "."], tree).pipe(
     Effect.mapError((cause) => new OxlintUnreadable({ message: `cannot run oxlint: ${cause.message}` })),
@@ -190,7 +194,8 @@ const runBudget = Effect.fn("runBudget")(
 
     const headTree = path.join(scratch, "head");
     if (held.length + others.length > 0) yield* materializeHead(root, head, [...holds, ...others], headTree);
-    const sites = yield* measure(headTree, budgets);
+    const plugin = path.join(import.meta.dir, "..", "dist", "index.js");
+    const sites = yield* measure(headTree, budgets, plugin);
     const heldSites = sites.filter((site) => holds.has(site.file));
     if (applies !== "ratchet") {
       return { applies, held: held.length, overruns: heldSites, advisory: sites.filter((site) => !holds.has(site.file)) } satisfies Verdict;
@@ -198,7 +203,7 @@ const runBudget = Effect.fn("runBudget")(
 
     const baseTree = path.join(scratch, "base");
     if (held.length > 0) yield* materializeBase(root, base, held, baseTree);
-    const growths = growthsOf(heldSites, yield* measure(baseTree, budgets));
+    const growths = growthsOf(heldSites, yield* measure(baseTree, budgets, plugin));
     const failing = new Set(growths.flatMap((growth) => growth.sites));
     return { applies, held: held.length, growths, advisory: sites.filter((site) => !failing.has(site)) } satisfies Verdict;
   },
@@ -239,16 +244,12 @@ function passes(verdict: Verdict): boolean {
 }
 
 const budget = Effect.gen(function* () {
-  const [first, second, ...extra] = process.argv.slice(2);
-  if (first === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
-
-  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const { source, quality } = yield* readQuality(root);
+  const { refs, root, source, quality } = yield* rangeGateInputs(USAGE);
   if (quality.size === undefined) {
     yield* Console.log(`${NAME}: ${source} declares no size budget`);
     return true;
   }
-  const { base, head } = yield* rangeEnds(first, second, root);
+  const { base, head } = yield* rangeEnds(refs.first, refs.second, root);
   const verdict = yield* runBudget(root, quality.size, quality.sources?.production ?? [], base, head);
 
   yield* Console.log(report(verdict));

package/scripts/size-rules.ts

@@ -30,10 +30,11 @@ const STATEMENTS = {
 
 const COMPLEXITY = {
   key: "complexity",
-  rule: "complexity",
-  options: { variant: "modified" },
-  measured: /has a complexity of (\d+)/,
-  limits: "The highest cyclomatic complexity a function may reach, a switch counted once",
+  rule: "cognitive-complexity",
+  plugin: "effect-channel",
+  options: {},
+  measured: /has a cognitive complexity of (\d+)/,
+  limits: "The highest cognitive complexity a function may reach, a switch counted once",
 } as const;
 
 const DEPTH = {
@@ -49,6 +50,14 @@ export const SIZE_RULES = [FILE_LINES, FUNCTION_LINES, STATEMENTS, COMPLEXITY, D
 export type SizeRule = (typeof SIZE_RULES)[number];
 export type LimitKey = SizeRule["key"];
 
+export function qualifiedName(rule: SizeRule): string {
+  return "plugin" in rule ? `${rule.plugin}/${rule.rule}` : rule.rule;
+}
+
+export function diagnosticCode(rule: SizeRule): string {
+  return "plugin" in rule ? `${rule.plugin}(${rule.rule})` : `eslint(${rule.rule})`;
+}
+
 // An absent limit turns its rule off.
 export type Budget = { readonly [K in LimitKey]?: number };
 

package/scripts/suppressions-ratchet.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { Console, Effect, Schema } from "effect";
-import { git, parentOrEmptyTree } from "./git.ts";
-import { runMain, Usage } from "./main.ts";
+import { git, parentOrEmptyTree, refArgs } from "./git.ts";
+import { runMain } from "./main.ts";
 
 export const SUPPRESSIONS = "oxlint-suppressions.json";
 
@@ -49,28 +49,27 @@ export const parseSuppressions = Effect.fn("parseSuppressions")(function* (
   return suppressions;
 });
 
+type Count = {
+  readonly file: string;
+  readonly rule: string;
+  readonly count: number;
+};
+
+function countsOf(suppressions: Suppressions): readonly Count[] {
+  return [...suppressions].flatMap(([file, rules]) => [...rules].map(([rule, count]) => ({ file, rule, count })));
+}
+
+function riseOf({ file, rule, count }: Count, before: number | undefined): readonly Rise[] {
+  if (before === undefined) return count > 0 ? [{ kind: "appeared", file, rule, head: count }] : [];
+  return count > before ? [{ kind: "rose", file, rule, base: before, head: count }] : [];
+}
+
 export function compareSuppressions(base: Suppressions, head: Suppressions): Ratchet {
-  const rises: Rise[] = [];
-  let counted = 0;
-  for (const [file, rules] of head) {
-    for (const [rule, count] of rules) {
-      counted += 1;
-      const before = base.get(file)?.get(rule);
-      if (before === undefined) {
-        if (count > 0) rises.push({ kind: "appeared", file, rule, head: count });
-      } else if (count > before) {
-        rises.push({ kind: "rose", file, rule, base: before, head: count });
-      }
-    }
-  }
-  let lowered = 0;
-  for (const [file, rules] of base) {
-    for (const [rule, count] of rules) {
-      if ((head.get(file)?.get(rule) ?? 0) < count) lowered += 1;
-    }
-  }
+  const counts = countsOf(head);
+  const rises = counts.flatMap((counted) => riseOf(counted, base.get(counted.file)?.get(counted.rule)));
+  const lowered = countsOf(base).filter(({ file, rule, count }) => (head.get(file)?.get(rule) ?? 0) < count).length;
   rises.sort((a, b) => a.file.localeCompare(b.file) || a.rule.localeCompare(b.rule));
-  return { counted, lowered, rises };
+  return { counted: counts.length, lowered, rises };
 }
 
 function describeRise(rise: Rise): string {
@@ -118,8 +117,7 @@ export const runTip = Effect.fn("runTip")(function* (tip: string) {
 });
 
 const ratchet = Effect.gen(function* () {
-  const [first, second, ...extra] = process.argv.slice(2);
-  if (first === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
+  const { first, second } = yield* refArgs(process.argv.slice(2), USAGE);
 
   const result = second !== undefined ? yield* runRange(first, second) : yield* runTip(first);
 

package/scripts/test-layout.ts

@@ -147,45 +147,47 @@ function importedNames(node: Record<string, unknown>): readonly string[] {
   return names;
 }
 
-function outOfProcessUse(node: Record<string, unknown>): string | undefined {
-  const type = node["type"];
+type UseCheck = (node: Record<string, unknown>) => string | undefined;
+
+function moduleUse(node: Record<string, unknown>): string | undefined {
+  const source = stringValue(node["source"]);
+  if (source === undefined) return undefined;
+  const banned = bannedModule(source);
+  if (banned !== undefined) return `imports node:${banned}`;
+  if (source !== "bun") return undefined;
+  const name = importedNames(node).find((candidate) => BANNED_BUN_NAMES.includes(candidate));
+  return name === undefined ? undefined : `imports ${name} from bun`;
+}
 
-  if (type === "ImportDeclaration" || type === "ExportNamedDeclaration" || type === "ExportAllDeclaration") {
-    const source = stringValue(node["source"]);
-    if (source === undefined) return undefined;
-    const banned = bannedModule(source);
-    if (banned !== undefined) return `imports node:${banned}`;
-    if (source === "bun") {
-      const name = importedNames(node).find((candidate) => BANNED_BUN_NAMES.includes(candidate));
-      if (name !== undefined) return `imports ${name} from bun`;
-    }
-    return undefined;
-  }
+function bunMemberUse(node: Record<string, unknown>): string | undefined {
+  if (identifierName(node["object"]) !== "Bun") return undefined;
+  const property = identifierName(node["property"]);
+  return property !== undefined && BANNED_BUN_NAMES.includes(property) ? `uses Bun.${property}` : undefined;
+}
 
-  if (type === "MemberExpression") {
-    if (identifierName(node["object"]) !== "Bun") return undefined;
-    const property = identifierName(node["property"]);
-    if (property !== undefined && BANNED_BUN_NAMES.includes(property)) return `uses Bun.${property}`;
-    return undefined;
-  }
+function callUse(node: Record<string, unknown>): string | undefined {
+  const callee = node["callee"];
+  const calleeName = identifierName(callee);
+  if (calleeName !== undefined && BANNED_GLOBAL_CALLS.includes(calleeName)) return `calls ${calleeName}`;
+  const argument = Array.isArray(node["arguments"]) ? node["arguments"][0] : undefined;
+  const specifier = isRecord(argument) ? stringValue(argument["expression"]) : undefined;
+  const banned = specifier === undefined ? undefined : bannedModule(specifier);
+  if (banned === undefined) return undefined;
+  if (isRecord(callee) && callee["type"] === "Import") return `imports node:${banned}`;
+  return calleeName === "require" ? `requires node:${banned}` : undefined;
+}
 
-  if (type === "CallExpression") {
-    const callee = node["callee"];
-    const calleeName = identifierName(callee);
-    if (calleeName !== undefined && BANNED_GLOBAL_CALLS.includes(calleeName)) {
-      return `calls ${calleeName}`;
-    }
-    const argument = Array.isArray(node["arguments"]) ? node["arguments"][0] : undefined;
-    const specifier = isRecord(argument) ? stringValue(argument["expression"]) : undefined;
-    if (specifier === undefined) return undefined;
-    const banned = bannedModule(specifier);
-    if (banned === undefined) return undefined;
-    if (isRecord(callee) && callee["type"] === "Import") return `imports node:${banned}`;
-    if (calleeName === "require") return `requires node:${banned}`;
-    return undefined;
-  }
+const USE_CHECKS = new Map<string, UseCheck>([
+  ["ImportDeclaration", moduleUse],
+  ["ExportNamedDeclaration", moduleUse],
+  ["ExportAllDeclaration", moduleUse],
+  ["MemberExpression", bunMemberUse],
+  ["CallExpression", callUse],
+]);
 
-  return undefined;
+function outOfProcessUse(node: Record<string, unknown>): string | undefined {
+  const type = node["type"];
+  return typeof type === "string" ? USE_CHECKS.get(type)?.(node) : undefined;
 }
 
 export const isolationViolations = Effect.fn("isolationViolations")(function* (file: string, source: string) {

package/scripts/test-report.ts

@@ -52,26 +52,31 @@ function attributesOf(source: string): Readonly<Record<string, string>> {
   return attributes;
 }
 
+const malformed = (reason: string) => new ReportError({ message: `the junit report is malformed: ${reason}` });
+
+const takeTag = Effect.fnUntraced(function* (open: Element[], match: RegExpExecArray): Effect.fn.Return<void, ReportError> {
+  const [, closing, tag, attributes, selfClosing] = match;
+  if (tag === undefined) return;
+  const parent = open.at(-1);
+  if (parent === undefined) return yield* malformed(`<${tag}> after the root closed`);
+  if (closing === "/") {
+    if (parent.tag !== tag) return yield* malformed(`</${tag}> closes <${parent.tag}>`);
+    open.pop();
+    return;
+  }
+  const element: Element = { tag, attributes: attributesOf(attributes ?? ""), children: [] };
+  parent.children.push(element);
+  if (selfClosing !== "/") open.push(element);
+});
+
 const parseElements = Effect.fnUntraced(function* (xml: string): Effect.fn.Return<Element, ReportError> {
-  const malformed = (reason: string) => new ReportError({ message: `the junit report is malformed: ${reason}` });
   const document: Element = { tag: "", attributes: {}, children: [] };
   const open: Element[] = [document];
   let consumed = 0;
   for (const match of xml.matchAll(MARKUP)) {
     if (xml.slice(consumed, match.index).includes("<")) return yield* malformed(`stray < before offset ${match.index}`);
     consumed = match.index + match[0].length;
-    const [, closing, tag, attributes, selfClosing] = match;
-    if (tag === undefined) continue;
-    const parent = open.at(-1);
-    if (parent === undefined) return yield* malformed(`<${tag}> after the root closed`);
-    if (closing === "/") {
-      if (parent.tag !== tag) return yield* malformed(`</${tag}> closes <${parent.tag}>`);
-      open.pop();
-      continue;
-    }
-    const element: Element = { tag, attributes: attributesOf(attributes ?? ""), children: [] };
-    parent.children.push(element);
-    if (selfClosing !== "/") open.push(element);
+    yield* takeTag(open, match);
   }
   if (xml.slice(consumed).includes("<")) return yield* malformed("stray < after the last element");
   if (open.length !== 1) return yield* malformed(`<${open.at(-1)?.tag}> never closes`);