paperlint 2.0.0

package/src/tex-requirements.harness.mjs

@@ -0,0 +1,238 @@
+/**
+ * `tex-requirements.ts` — the TeX packages the venue profiles declare, parsed at the boundary.
+ *
+ * Tables, in order:
+ *   1. the SHIPPED data: every profile passes the schema, and the facts that have already cost a
+ *      paper (the acmart fonts, binhex, fancyhdr) are declared;
+ *   2. the schema REJECTS what it must — each bad profile names the offending path;
+ *   3. what a paper gets: its venue plus the base set, or the base set with the reason said.
+ */
+import assert from "node:assert/strict";
+import {
+  copyFileSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const VENUES = join(
+  HERE,
+  "..",
+  "skills",
+  "submit-paper",
+  "references",
+  "venues",
+);
+const R = await import(join(HERE, "tex-requirements.ts"));
+
+let n = 0;
+const check = (label, cond, detail = "") => {
+  assert.ok(cond, `${label}${detail ? ` — ${detail}` : ""}`);
+  n++;
+};
+const throws = (fn) => {
+  try {
+    fn();
+    return "";
+  } catch (e) {
+    return e.message;
+  }
+};
+const read = (f) =>
+  R.parseProfile(readFileSync(join(VENUES, f), "utf8"), f, VENUES);
+
+// ── 1. the shipped data ─────────────────────────────────────────────────────────────────
+const venues = R.venueNames(VENUES);
+// Guards: keeping tex-base out of the venue list — it would be offered as a venue named tex-base.
+check(
+  "venueNames: the .jsonc profiles, without the base set",
+  venues.length >= 3 && !venues.includes("tex-base"),
+  venues.join(","),
+);
+for (const v of venues)
+  check(
+    `${v}.jsonc passes the schema`,
+    throws(() => read(`${v}.jsonc`)) === "",
+    throws(() => read(`${v}.jsonc`)),
+  );
+const base = read("tex-base.jsonc");
+check(
+  "tex-base: the programs the skills run (texcount, checkcites) are declared as TOOLS",
+  base.tools.texcount?.[0] === "texcount" &&
+    base.tools.checkcites?.[0] === "checkcites",
+);
+check(
+  "tex-base: cm-super — without it pdflatex silently rasterizes to Type 3",
+  "cm-super" in base.packages,
+);
+
+// The whole profile, parsed the way the other harnesses read these files — never a line of text.
+const templateOf = (v) =>
+  ts.parseConfigFileTextToJson(
+    v,
+    readFileSync(join(VENUES, `${v}.jsonc`), "utf8"),
+  ).config.template;
+const acm = venues.filter((v) => templateOf(v) === "acmart");
+check(
+  "at least one acmart venue is shipped (else the next checks see nothing)",
+  acm.length > 0,
+);
+for (const v of acm) {
+  const tex = read(`${v}.jsonc`);
+  // acmart.cls checks ALL THREE font packages and falls back to Computer Modern SILENTLY when any
+  // is missing; newtx needs binhex.tex (kastrup) or the build stops hard; fancyhdr (#37).
+  for (const [pkg, file] of [
+    ["libertine", "libertine.sty"],
+    ["inconsolata", "zi4.sty"],
+    ["newtx", "newtxmath.sty"],
+    ["kastrup", "binhex.tex"],
+    // Guards: #37 — fancyhdr was held up by an accident of the base image and is absent on a
+    // minimal one.
+    ["fancyhdr", "fancyhdr.sty"],
+    ["acmart", "acmart.cls"],
+  ])
+    check(
+      `🔴 ${v}: declares ${pkg}, proved by ${file}`,
+      tex.packages[pkg]?.includes(file),
+    );
+}
+// Venues on ONE template must not drift apart: a second list is how the old installer's three
+// dictionaries diverged.
+const byTemplate = new Map();
+for (const v of venues) {
+  const t = templateOf(v);
+  byTemplate.set(t, [...(byTemplate.get(t) ?? []), v]);
+}
+for (const [t, vs] of byTemplate)
+  check(
+    `venues on template ${t} declare the SAME packages (${vs.join(", ")})`,
+    new Set(vs.map((v) => JSON.stringify(read(`${v}.jsonc`)))).size === 1,
+  );
+
+// ── 2. the schema rejects ───────────────────────────────────────────────────────────────
+const tmp = realpathSync(mkdtempSync(join(tmpdir(), "rpp-texreq-h-")));
+copyFileSync(join(VENUES, R.SCHEMA_FILE), join(tmp, R.SCHEMA_FILE));
+const bad = (text) => throws(() => R.parseProfile(text, "bad.jsonc", tmp));
+const BAD = [
+  ["no `tex` block at all", `{ "template": "acmart" }`, "tex"],
+  // Guards: typo detection — `templat` would be accepted and the field silently unread.
+  [
+    "an unknown top-level key (a typo)",
+    `{ "tex": { "packages": { "a": ["a.sty"] } }, "templat": "x" }`,
+    "additional properties",
+  ],
+  [
+    "a package with NO proof file",
+    `{ "tex": { "packages": { "acmart": [] } } }`,
+    ".tex.packages['acmart']",
+  ],
+  [
+    "a package name tlmgr would not know (upper case)",
+    `{ "tex": { "packages": { "Acmart": ["acmart.cls"] } } }`,
+    "property name",
+  ],
+  [
+    "a proof that is a path, not a file name",
+    `{ "tex": { "packages": { "a": ["tex/a.sty"] } } }`,
+    "pattern",
+  ],
+  ["an empty packages map", `{ "tex": { "packages": {} } }`, "fewer than 1"],
+  [
+    "an unknown key inside tex",
+    `{ "tex": { "packages": { "a": ["a.sty"] }, "pkgs": {} } }`,
+    "additional properties",
+  ],
+];
+for (const [label, text, says] of BAD) {
+  const msg = bad(text);
+  check(
+    `schema rejects ${label}, and says where`,
+    msg.includes("does not match") && msg.includes(says),
+    msg,
+  );
+}
+check(
+  "not JSONC at all: named as such, not as a schema failure",
+  bad(`{ "tex": `).includes("not valid JSONC"),
+  bad(`{ "tex": `),
+);
+check(
+  "comments and trailing commas ARE JSONC",
+  bad(`// quote\n{ "tex": { "packages": { "a": ["a.sty"], }, }, }`) === "",
+);
+rmSync(tmp, { recursive: true, force: true });
+
+// ── 3. what a paper gets ────────────────────────────────────────────────────────────────
+{
+  const r = R.requirementsFor(null, VENUES);
+  // Guards: saying WHY a paper runs on the base set.
+  check(
+    "no venue.json → the base set, and the source says so",
+    r.source.includes("no venue.json") &&
+      "hyperref" in r.tex.packages &&
+      !("acmart" in r.tex.packages),
+    r.source,
+  );
+}
+{
+  const r = R.requirementsFor("nowhere", VENUES);
+  check(
+    "a venue with no profile → the base set, and the source names the venue",
+    r.source.includes("venue nowhere has no profile") &&
+      !("acmart" in r.tex.packages),
+    r.source,
+  );
+}
+check(
+  "the base file is not a venue: `tex-base` gets the base set with the reason",
+  R.requirementsFor("tex-base", VENUES).source.includes("has no profile"),
+);
+{
+  const r = R.requirementsFor(acm[0], VENUES);
+  check(
+    "a known venue → its packages ON TOP OF the base set",
+    r.source === `venue ${acm[0]}` &&
+      "acmart" in r.tex.packages &&
+      "hyperref" in r.tex.packages &&
+      "texcount" in r.tex.tools,
+    r.source,
+  );
+}
+{
+  const m = R.mergeRequirements(
+    { packages: { a: ["a.sty"] }, tools: {} },
+    { packages: { a: ["a2.sty"], b: ["b.sty"] }, tools: { t: ["t"] } },
+  );
+  // Guards: the union — two venues proving one package by different files would lose one proof.
+  check(
+    "mergeRequirements: a package declared twice keeps every proof of both",
+    JSON.stringify(m) ===
+      '{"packages":{"a":["a.sty","a2.sty"],"b":["b.sty"]},"tools":{"t":["t"]}}',
+    JSON.stringify(m),
+  );
+}
+{
+  const u = R.declaredUnion(VENUES);
+  const names = R.packageNames(u.tex);
+  check(
+    "declaredUnion: base + every venue — what `paperlint toolchain` installs",
+    u.profiles === venues.length + 1 &&
+      names.includes("acmart") &&
+      names.includes("lineno") &&
+      names.includes("texcount") &&
+      names.includes("hyperref"),
+    names.join(","),
+  );
+  check(
+    "packageNames: sorted, unique",
+    names.join() === [...new Set(names)].sort().join(),
+  );
+}
+
+console.log(`tex-requirements: ${n} checks passed`);

package/src/tex-requirements.ts

@@ -0,0 +1,181 @@
+/**
+ * WHICH TeX LIVE PACKAGES A PAPER NEEDS — read from the venue profiles, not written in an installer.
+ *
+ * 🔴 WHY THE LIST MOVED OUT OF THE INSTALLER (issue #26). Which packages a paper needs is a property
+ * of its venue's TEMPLATE, not of the machine. While the list lived in `ensure-toolchain.sh` it was
+ * one flat set for every paper, edited whenever a build broke, and kept in THREE dictionaries (apt
+ * names, CTAN names, the file contract) that drifted apart twice. Now each venue profile carries a
+ * `tex` block — CTAN package → the files that prove it is present — and `tex-base.jsonc` carries
+ * what every paper gets. `paperlint toolchain` installs the union; `paperlint build` checks the paper's share.
+ *
+ * ── THE DATA IS PARSED AT THE BOUNDARY ───────────────────────────────────────────
+ * A profile is JSONC (every number in it carries a quote from the venue's instructions), parsed
+ * by TypeScript's own JSONC reader — the parser the harnesses already read these files with — and
+ * validated against `venue-profile.schema.json` by ajv, the JSON Schema validator ESLint itself
+ * validates rule options with. After `parseProfile` returns, the rest of paperlint holds a typed
+ * `TexRequirements` and never looks at the text again; a malformed profile throws with the path
+ * of every violation, it is never read as "no packages".
+ *
+ * Where the profiles live is answered by `packageVenuesDir()` in consumer.mjs — the one module
+ * allowed to know where this package is installed (rule 10).
+ */
+// eslint-disable-next-line boundaries/dependencies -- legacy I/O, moves behind a port in #76
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+// eslint-disable-next-line boundaries/dependencies -- legacy layer, moves behind a port in #76
+import Ajv from "ajv";
+import { packageVenuesDir } from "../skills/paper-pipeline/scripts/consumer.mjs";
+
+/** CTAN package name → the names that prove it is installed. */
+export type PackageProofs = Readonly<Record<string, readonly string[]>>;
+
+export interface TexRequirements {
+  /** Proved by `kpsewhich <file>` — files LaTeX loads. */
+  readonly packages: PackageProofs;
+  /** Proved by an executable in TeX Live's bin directory — programs, not files. */
+  readonly tools: PackageProofs;
+}
+
+/** The requirements for one paper, and where they came from — printed, never guessed silently. */
+export interface PaperRequirements {
+  readonly source: string;
+  readonly tex: TexRequirements;
+}
+
+/** The profile every paper gets, and the only one a paper with an unknown venue gets. */
+export const BASE_PROFILE = "tex-base.jsonc";
+export const SCHEMA_FILE = "venue-profile.schema.json";
+const PROFILE_EXT = ".jsonc";
+
+export const NO_REQUIREMENTS: TexRequirements = { packages: {}, tools: {} };
+
+type Ts = typeof import("typescript");
+let ts: Ts | null = null;
+/** TypeScript is loaded only when a profile is read: `paperlint lint` never pays for it. */
+function typescript(): Ts {
+  ts ??= createRequire(import.meta.url)("typescript") as Ts;
+  return ts;
+}
+
+type Validate = ReturnType<Ajv.Ajv["compile"]>;
+const validators = new Map<string, Validate>();
+function validatorFor(dir: string): Validate {
+  const known = validators.get(dir);
+  if (known) return known;
+  const schema: object = JSON.parse(
+    readFileSync(join(dir, SCHEMA_FILE), "utf8"),
+  );
+  const v = new Ajv({ allErrors: true }).compile(schema);
+  validators.set(dir, v);
+  return v;
+}
+
+/** Every violation as `<file>: <path> <message>` — one line each, so all of them are fixed at once. */
+function violations(file: string, v: Validate): string[] {
+  return (v.errors ?? []).map(
+    (e) => `${file}: ${e.dataPath || "(top level)"} ${e.message ?? ""}`,
+  );
+}
+
+/**
+ * The text of one profile → its typed requirements, or an Error naming every problem.
+ *
+ * @param text  the file's contents
+ * @param file  the name to put in messages
+ * @param dir   the directory holding the schema (the shipped venues directory by default)
+ */
+export function parseProfile(
+  text: string,
+  file: string,
+  dir: string = packageVenuesDir(),
+): TexRequirements {
+  const { config, error } = typescript().parseConfigFileTextToJson(file, text);
+  if (error)
+    throw new Error(
+      `${file}: not valid JSONC — ${typescript().flattenDiagnosticMessageText(error.messageText, " ")}`,
+    );
+  const validate = validatorFor(dir);
+  if (!validate(config))
+    throw new Error(
+      `${file} does not match ${SCHEMA_FILE}:\n  ${violations(file, validate).join("\n  ")}`,
+    );
+  const tex = (config as { tex: Partial<TexRequirements> }).tex;
+  return { packages: tex.packages ?? {}, tools: tex.tools ?? {} };
+}
+
+function readProfile(dir: string, file: string): TexRequirements {
+  return parseProfile(readFileSync(join(dir, file), "utf8"), file, dir);
+}
+
+/** The venues that have a profile — every `.jsonc` in the directory except the base set. */
+export function venueNames(dir: string = packageVenuesDir()): string[] {
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(PROFILE_EXT) && f !== BASE_PROFILE)
+    .map((f) => f.slice(0, -PROFILE_EXT.length))
+    .sort();
+}
+
+/** The union of two sets of requirements; a package declared by both keeps every proof of both. */
+export function mergeRequirements(
+  a: TexRequirements,
+  b: TexRequirements,
+): TexRequirements {
+  const union = (x: PackageProofs, y: PackageProofs): PackageProofs => {
+    const out: Record<string, readonly string[]> = { ...x };
+    for (const [name, proofs] of Object.entries(y))
+      out[name] = [...new Set([...(out[name] ?? []), ...proofs])];
+    return out;
+  };
+  return {
+    packages: union(a.packages, b.packages),
+    tools: union(a.tools, b.tools),
+  };
+}
+
+/** Every package name, packages and tools together, sorted — what tlmgr is asked for. */
+export function packageNames(tex: TexRequirements): string[] {
+  return [
+    ...new Set([...Object.keys(tex.packages), ...Object.keys(tex.tools)]),
+  ].sort();
+}
+
+/**
+ * What ONE paper needs: the base set plus its venue's block. A paper with no venue, or a venue this
+ * package has no profile for, gets the base set — and the source says which, so an ACM paper built
+ * without `venue.json` is visibly running on the base set rather than silently.
+ */
+export function requirementsFor(
+  venue: string | null,
+  dir: string = packageVenuesDir(),
+): PaperRequirements {
+  const base = readProfile(dir, BASE_PROFILE);
+  if (venue === null)
+    return { source: "the base set (no venue.json)", tex: base };
+  const file = `${venue}${PROFILE_EXT}`;
+  if (
+    venue === BASE_PROFILE.slice(0, -PROFILE_EXT.length) ||
+    !existsSync(join(dir, file))
+  )
+    return {
+      source: `the base set (venue ${venue} has no profile in paperlint)`,
+      tex: base,
+    };
+  return {
+    source: `venue ${venue}`,
+    tex: mergeRequirements(base, readProfile(dir, file)),
+  };
+}
+
+/** Everything any profile declares — the set `paperlint toolchain` installs, so one tree builds any paper. */
+export function declaredUnion(dir: string = packageVenuesDir()): {
+  readonly tex: TexRequirements;
+  readonly profiles: number;
+} {
+  const venues = venueNames(dir);
+  const tex = venues.reduce(
+    (acc, v) => mergeRequirements(acc, readProfile(dir, `${v}${PROFILE_EXT}`)),
+    readProfile(dir, BASE_PROFILE),
+  );
+  return { tex, profiles: venues.length + 1 };
+}