paperlint 4.2.0 → 6.0.0

package/src/venue-rules.test.ts

@@ -1,6 +1,6 @@
 /**
- * The venue rules (`pdf/fresh` · `pdf/profile` · `pdf/fonts` · `pdf/geometry` · `pdf/limits` ·
- * `pdf/body-size` · `pdf/measured`) over a paper held in memory: `paper.tex`, `paperlint.json`,
+ * The venue rules (`pdf/fresh` · `pdf/profile` · `pdf/fonts` · `pdf/geometry` · `pdf/body-size` ·
+ * `pdf/measured` · `format/page-limit` · `anonymity/identity`) over a paper held in memory: `paper.tex`, `paperlint.json`,
  * `_build/paper.facts.json` and the PDF the facts describe. The venue profiles are the SHIPPED
  * ones, read from the package's venues directory, so a profile edit that breaks a check shows here.
  *
@@ -13,7 +13,17 @@ import { describe, expect, it } from "vitest";
 import { memoryFiles } from "./adapters/memory/index.ts";
 import { sha256Hex } from "./domain/sha256.ts";
 import { presetsDir } from "./package-dirs.ts";
-import { VENUE_RULE_LEVELS, venueRules } from "./venue-rules.ts";
+import {
+  ANONYMITY_RULE_LEVELS,
+  anonymityRules,
+  judgeBodyEnd,
+  PAGE_LIMIT_RULE_LEVELS,
+  pageLimitRules,
+  VENUE_RULE_LEVELS,
+  venueRules,
+  type Resolved,
+} from "./venue-rules.ts";
+import { NO_FORMAT } from "./tex-requirements.ts";
 import { buildConfig, OPTIONAL_RULES, SHIPPED_RULES } from "./cli.ts";
 import { present } from "../test/support.ts";
 
@@ -44,7 +54,12 @@ type Patch = (f: Facts) => void;
 /** The facts of a short agenticdev paper that meets every number in its profile. */
 function goodFacts(): Facts {
   return {
-    schema: 2,
+    schema: 3,
+    pages_text: [],
+    metadata: {},
+    links: [],
+    bib_anchor_page: null,
+    appendix_anchor_page: null,
     pdf: "paper.pdf",
     pdf_sha256: sha256Hex(PDF_BYTES),
     venue: "agenticdev",
@@ -122,18 +137,29 @@ function lint(
   cwd?: string,
 ): Finding[] {
   const files = memoryFiles(paperFiles(p));
-  const rules = venueRules({ files, venuesDir: VENUES });
+  const deps = { files, venuesDir: VENUES };
+  const rules = [
+    ...Object.entries(venueRules(deps)).map(
+      ([n, r]) => [`pdf/${n}`, r] as const,
+    ),
+    ...Object.entries(pageLimitRules(deps)).map(
+      ([n, r]) => [`format/${n}`, r] as const,
+    ),
+    ...Object.entries(anonymityRules(deps)).map(
+      ([n, r]) => [`anonymity/${n}`, r] as const,
+    ),
+  ];
   const out: Finding[] = [];
-  for (const [name, rule] of Object.entries(rules)) {
+  for (const [id, rule] of rules) {
     const visitor = rule.create({
       filename,
       ...(cwd === undefined ? {} : { cwd }),
       sourceCode: { text: TEX },
       options:
-        name === "geometry" && Object.keys(options).length ? [options] : [],
+        id === "pdf/geometry" && Object.keys(options).length ? [options] : [],
       report: (d) =>
         out.push({
-          rule: `pdf/${name}`,
+          rule: id,
           messageId: d.messageId,
           message: Object.entries(d.data ?? {}).reduce(
             (m, [k, v]) => m.replaceAll(`{{${k}}}`, String(v)),
@@ -456,39 +482,21 @@ describe("pdf/geometry", () => {
   });
 });
 
-describe("pdf/limits", () => {
+describe("format/page-limit", () => {
   it.each<[string, (f: Facts) => void, string[], RegExp | null]>([
     [
       "one body page over the short-paper limit",
       (f: Facts) => (f.body_pages = 6),
-      ["pdf/limits:pages"],
+      ["format/page-limit:pages"],
       /body pages: 6, over the limit 5 for agenticdev\/short/,
     ],
     [
       "one reference page over",
       (f: Facts) => (f.ref_pages = 3),
-      ["pdf/limits:pages"],
+      ["format/page-limit:pages"],
       /reference pages: 3, over the limit 2/,
     ],
     ["exactly at the limit", (f: Facts) => (f.body_pages = 5), [], null],
-    [
-      "a reference font below the range",
-      (f: Facts) => (f.ref_pt = 6),
-      ["pdf/limits:refPt"],
-      /6 pt/,
-    ],
-    [
-      "6.8 pt is inside the range once the measuring drift (body_pt_tol) is allowed",
-      (f: Facts) => (f.ref_pt = 6.8),
-      [],
-      null,
-    ],
-    [
-      "no reference font measured (no bibliography) is not a finding",
-      (f: Facts) => (f.ref_pt = null),
-      [],
-      null,
-    ],
   ])("%s", (_, patch, want, text) => {
     const fs = lint({ venue: DECL, facts: withFacts(patch) });
     expect(ids(fs)).toEqual(want);
@@ -497,7 +505,9 @@ describe("pdf/limits", () => {
 
   it("a longer kind of the same venue passes the same page count", () => {
     const facts = withFacts((f) => (f.body_pages = 9));
-    expect(ids(lint({ venue: DECL, facts }))).toEqual(["pdf/limits:pages"]);
+    expect(ids(lint({ venue: DECL, facts }))).toEqual([
+      "format/page-limit:pages",
+    ]);
     expect(
       lint({ venue: { extends: "paperlint:agenticdev", kind: "full" }, facts }),
     ).toEqual([]);
@@ -517,6 +527,21 @@ describe("pdf/body-size", () => {
       (f: Facts) => (f.body_pt = null),
       ["pdf/body-size:bodyMissing"],
     ],
+    [
+      "a reference font below the range",
+      (f: Facts) => (f.ref_pt = 6),
+      ["pdf/body-size:refPt"],
+    ],
+    [
+      "6.8 pt is inside the reference range once the measuring drift (body_pt_tol) is allowed",
+      (f: Facts) => (f.ref_pt = 6.8),
+      [],
+    ],
+    [
+      "no reference font measured (no bibliography) is not a finding",
+      (f: Facts) => (f.ref_pt = null),
+      [],
+    ],
   ])("%s", (_, patch, want) => {
     expect(ids(lint({ venue: DECL, facts: withFacts(patch) }))).toEqual(want);
   });
@@ -537,22 +562,33 @@ describe("paperlint's own config turns the venue rules on for every paper.tex",
     "the paper.tex block's rules",
   );
 
-  it.each(Object.entries(VENUE_RULE_LEVELS))("%s is on at %s", (id, level) => {
+  it.each(
+    Object.entries({
+      ...VENUE_RULE_LEVELS,
+      ...PAGE_LIMIT_RULE_LEVELS,
+      ...ANONYMITY_RULE_LEVELS,
+    }),
+  )("%s is on at %s", (id, level) => {
     expect(texRules[id]).toBe(level);
     expect(SHIPPED_RULES.has(id)).toBe(true);
     expect(OPTIONAL_RULES.has(id)).toBe(false);
   });
 
-  it("the six rules of the issue are errors except body-size, and measured is a warning", () => {
+  it("the venue rules are errors except measured, which is a warning", () => {
     expect(VENUE_RULE_LEVELS).toEqual({
       "pdf/fresh": "error",
       "pdf/profile": "error",
       "pdf/fonts": "error",
       "pdf/geometry": "error",
-      "pdf/limits": "error",
-      "pdf/body-size": "warn",
+      "pdf/body-size": "error",
       "pdf/measured": "warn",
     });
+    expect(PAGE_LIMIT_RULE_LEVELS).toEqual({ "format/page-limit": "error" });
+    expect(ANONYMITY_RULE_LEVELS).toEqual({ "anonymity/identity": "error" });
+  });
+
+  it("the rule the page limit was checked by before is not shipped", () => {
+    expect(SHIPPED_RULES.has("pdf/limits")).toBe(false);
   });
 
   it("pdf/last-page-balance stays optional", () => {
@@ -573,6 +609,10 @@ const type1 = (names: readonly string[]): Font[] =>
     program: "Type1",
   }));
 
+/** `n` pages of body text, one per page, as `pages_text` holds them. */
+const bodyPages = (n: number): string[] =>
+  Array.from({ length: n }, (_, i) => `Body page ${String(i + 1)}\n`);
+
 const ieeeFacts = (patch: Patch = () => {}): Facts =>
   withFacts((f) => {
     f.page_w_in = 8.5;
@@ -582,6 +622,11 @@ const ieeeFacts = (patch: Patch = () => {}): Facts =>
     f.ref_pt = 8.3;
     f.body_pages = 12;
     f.ref_pages = 1;
+    // Twelve pages of body, the references heading on the thirteenth.
+    f.pages_text = [
+      ...bodyPages(12),
+      "R EFERENCES\n[1] D. E. Knuth, Literate Programming.\nLLM Usage Statement\n",
+    ];
     f.fonts = type1([
       "NimbusRomNo9L-Medi",
       "NimbusRomNo9L-Regu",
@@ -593,16 +638,34 @@ const ieeeFacts = (patch: Patch = () => {}): Facts =>
 
 describe("the IEEE conference family and AIDC", () => {
   const FAMILY = { extends: "paperlint:ieee-conference" };
-  const AIDC = { extends: "paperlint:aidc", kind: "regular" };
+  const IDENTITY = ["Ada Example", "adaexample", "ada@example.org"];
+  const AIDC = {
+    extends: "paperlint:aidc",
+    kind: "regular",
+    identity: IDENTITY,
+  };
 
   it.each([
     ["the family", FAMILY],
     ["aidc/regular", AIDC],
-    ["aidc/short", { extends: "paperlint:aidc", kind: "short" }],
   ])("the measured IEEEtran build passes %s", (_, venue) => {
     expect(lint({ venue, facts: ieeeFacts() })).toEqual([]);
   });
 
+  it("aidc/short: six body pages pass, seven fail", () => {
+    const short = { ...AIDC, kind: "short" };
+    const pages = (n: number) =>
+      ieeeFacts((f) => {
+        f.pages_text = [...bodyPages(n), "References\n"];
+      });
+    expect(lint({ venue: short, facts: pages(6) })).toEqual([]);
+    const fs = lint({ venue: short, facts: pages(7) });
+    expect(ids(fs)).toEqual(["format/page-limit:pages"]);
+    expect(fs[0]?.message).toBe(
+      "body pages (up to the references on page 8): 7, over the limit 6 for aidc/short — a desk reject; cut the text",
+    );
+  });
+
   it.each([
     ["the family", FAMILY],
     ["aidc", AIDC],
@@ -627,14 +690,52 @@ describe("the IEEE conference family and AIDC", () => {
     expect(ids(fs)).toEqual(["pdf/fonts:noFamily"]);
     expect(fs[0]?.message).toMatch(/NimbusRomNo9L/);
   });
+});
 
+describe("pdf/body-size on the IEEE family: 10 pt body, 8 pt references", () => {
   it("a body size off the family's 10 pt fails pdf/body-size", () => {
     expect(
-      ids(lint({ venue: AIDC, facts: ieeeFacts((f) => (f.body_pt = 9.3)) })),
+      ids(
+        lint({
+          venue: {
+            extends: "paperlint:aidc",
+            kind: "regular",
+            identity: ["Ada Example"],
+          },
+          facts: ieeeFacts((f) => (f.body_pt = 9.3)),
+        }),
+      ),
     ).toEqual(["pdf/body-size:body"]);
   });
 
-  it("🔴 AIDC's page limit is not gated: banal's body count of 13 — a correct paper with its LLM Usage Statement before the references — is not a finding", () => {
+  it.each([
+    ["\\scriptsize, 7 pt", 7.3],
+    ["\\small, 9 pt", 9.3],
+  ])(
+    "a bibliography in %s instead of the class's 8 pt fails pdf/body-size",
+    (_, got) => {
+      const fs = lint({
+        venue: { extends: "paperlint:ieee-conference" },
+        facts: ieeeFacts((f) => (f.ref_pt = got)),
+      });
+      expect(fs.map((f) => f.message)).toEqual([
+        `the reference font size is ${String(got)} pt, outside 8 pt for ieee-conference (allowing ±0.5 pt for the measuring drift) — fix the bibliography's font size`,
+      ]);
+    },
+  );
+});
+
+/** An AIDC regular paper (12 body pages), for the page-limit tests. */
+const AIDC_REGULAR = {
+  extends: "paperlint:aidc",
+  kind: "regular",
+  identity: ["Ada Example"],
+};
+
+describe("format/page-limit on AIDC: the body is counted up to the references", () => {
+  const AIDC = AIDC_REGULAR;
+
+  it("🔴 AIDC's body is counted before the references, not by banal: banal's 13 — the statement and an appendix after the references counted as body — is not a finding", () => {
     expect(
       lint({
         venue: AIDC,
@@ -643,6 +744,197 @@ describe("the IEEE conference family and AIDC", () => {
     ).toEqual([]);
   });
 
+  it("…while a thirteenth page of body before the references is", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => {
+        f.pages_text = [...bodyPages(13), "7 References\n"];
+      }),
+    });
+    expect(ids(fs)).toEqual(["format/page-limit:pages"]);
+  });
+
+  it("🔴 a body that runs onto the thirteenth page, the references below it there: 13 pages, a finding", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => {
+        f.pages_text = [
+          ...bodyPages(12),
+          "the last lines of the conclusion\nR EFERENCES\n[1] D. E. Knuth.\n",
+        ];
+      }),
+    });
+    expect(ids(fs)).toEqual(["format/page-limit:pages"]);
+    expect(fs[0]?.message).toMatch(
+      /^body pages \(up to the references on page 13\): 13, over the limit 12/,
+    );
+  });
+
+  it("no references heading on any page: said, not passed", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => (f.pages_text = ["Body\n", "Body\n"])),
+    });
+    expect(ids(fs)).toEqual(["format/page-limit:noReferences"]);
+    expect(fs[0]?.message).toMatch(/NOT counted/);
+  });
+
+  it("the references count needs no banal: facts without geometry are still judged", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => {
+        f.geometry_source = null;
+        f.pages_text = [...bodyPages(13), "References\n"];
+      }),
+    });
+    expect(ids(fs)).toEqual([
+      "format/page-limit:pages",
+      "pdf/measured:noGeometry",
+    ]);
+  });
+});
+
+describe("format/page-limit on AIDC: an appendix ends the body too", () => {
+  const AIDC = AIDC_REGULAR;
+
+  it("🔴 an appendix before the references is not body: the body ends where hyperref anchors the appendix", () => {
+    const facts = ieeeFacts((f) => {
+      f.pages_text = [
+        ...bodyPages(12),
+        "Appendix A.\nDetailed results\n",
+        "References\n[1] A.\n",
+      ];
+      f.bib_anchor_page = 14;
+      f.appendix_anchor_page = 13;
+    });
+    expect(ids(lint({ venue: AIDC, facts }))).toEqual([]);
+    // Without hyperref's anchor for it, the appendix is body — the count this rule had before.
+    facts.appendix_anchor_page = null;
+    expect(lint({ venue: AIDC, facts })[0]?.message).toMatch(
+      /^body pages \(up to the references on page 14\): 13, over the limit 12/,
+    );
+  });
+});
+
+describe("format/page-limit on AIDC: the two signals of where the references start disagree", () => {
+  const AIDC = AIDC_REGULAR;
+
+  it("hyperref's first entry on a page with no «References» line: unclear, said, not passed", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => {
+        f.pages_text = [...bodyPages(12), "References\n[1] A.\n", "[2] B.\n"];
+        f.bib_anchor_page = 14;
+      }),
+    });
+    expect(ids(fs)).toEqual(["format/page-limit:unclear"]);
+    expect(fs[0]?.message).toBe(
+      "could not tell where the body ends, so it was NOT counted against aidc's limit: the first bibliography entry is on page 14 (hyperref's destination), and no line on page 14 reads «References». Check the headings of the bibliography and the appendix, and that nothing before them reads «References» above a [1]",
+    );
+  });
+
+  it("hyperref anchors the appendix on a page with no line reading «Appendix»: unclear", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => {
+        f.appendix_anchor_page = 5;
+      }),
+    });
+    expect(fs[0]?.message).toMatch(
+      /: hyperref anchors the appendix on page 5, and no line on page 5 reads «Appendix»\./,
+    );
+  });
+
+  it("a confirmed heading on another page than hyperref's first entry: unclear, naming both", () => {
+    const fs = lint({
+      venue: AIDC,
+      facts: ieeeFacts((f) => {
+        f.pages_text = [
+          "References\n[1] quoted in the body\n",
+          ...bodyPages(11),
+          "References\n[1] A.\n",
+        ];
+        f.bib_anchor_page = 13;
+      }),
+    });
+    expect(fs[0]?.message).toMatch(
+      /and the «References» heading followed by \[1\] is on page 1\./,
+    );
+  });
+});
+
+/** An AIDC paper that declares who wrote it. */
+const BLIND = {
+  extends: "paperlint:aidc",
+  kind: "regular",
+  identity: ["Ada Example", "adaexample", "ada@example.org"],
+};
+const said = (patch: Patch) => ieeeFacts(patch);
+
+describe("anonymity/identity — a blind venue (AIDC)", () => {
+  it("no identity declared: an error, built or not — a missing input is not a clean pass", () => {
+    const noIdentity = { extends: "paperlint:aidc", kind: "regular" };
+    const built = lint({ venue: noIdentity, facts: ieeeFacts() });
+    expect(ids(built)).toEqual(["anonymity/identity:noIdentity"]);
+    expect(built[0]?.message).toMatch(/"identity": \["Your Name"/);
+    expect(ids(lint({ venue: noIdentity, facts: null }))).toEqual([
+      "anonymity/identity:noIdentity",
+      "pdf/measured:unbuilt",
+    ]);
+    expect(
+      ids(lint({ venue: { ...noIdentity, identity: [] }, facts: ieeeFacts() })),
+    ).toEqual(["anonymity/identity:noIdentity"]);
+  });
+
+  it("declared and not built: silent — pdf/measured already says it was not built", () => {
+    expect(ids(lint({ venue: BLIND, facts: null }))).toEqual([
+      "pdf/measured:unbuilt",
+    ]);
+  });
+
+  it("a name on a page, the metadata and a link target: one finding each, with the place", () => {
+    const fs = lint({
+      venue: BLIND,
+      facts: said((f) => {
+        f.pages_text = [
+          "Title\nAda\nExample\n",
+          ...bodyPages(11),
+          "References\n",
+        ];
+        f.metadata = { Author: "Ada Example", Producer: "pdfTeX-1.40.25" };
+        f.links = [{ page: 2, uri: "https://github.com/adaexample/tool" }];
+      }),
+    });
+    expect(fs.map((f) => f.message)).toEqual([
+      "PDF, page 1: «Ada Example» matches «Ada Example» in `identity`, and aidc reviews double-blind — remove it, or refer to your own work in the third person",
+      "PDF metadata: Author: «Ada Example» matches «Ada Example» in `identity`, and aidc reviews double-blind — remove it, or refer to your own work in the third person",
+      "link target on page 2 (https://github.com/adaexample/tool): «adaexample» matches «Ada Example» in `identity`, and aidc reviews double-blind — remove it, or refer to your own work in the third person",
+    ]);
+  });
+
+  it("an anonymous-hosting link names nobody, and is not a finding", () => {
+    expect(
+      lint({
+        venue: BLIND,
+        facts: said((f) => {
+          f.links = [
+            { page: 1, uri: "https://anonymous.4open.science/r/tool-1A2B" },
+          ];
+        }),
+      }),
+    ).toEqual([]);
+  });
+
+  it("a venue that is not blind: silent, with or without identity, whatever the PDF says", () => {
+    const facts = withFacts((f) => (f.pages_text = ["Ada Example\n"]));
+    expect(lint({ venue: DECL, facts })).toEqual([]);
+    expect(
+      lint({ venue: { ...DECL, identity: ["Ada Example"] }, facts }),
+    ).toEqual([]);
+  });
+});
+
+describe("an AIDC kind", () => {
   it("an AIDC kind that does not exist names the two that do", () => {
     const fs = lint({ venue: { extends: "paperlint:aidc", kind: "wip" } });
     expect(ids(fs)).toContain("pdf/profile:kindUnknown");
@@ -677,7 +969,9 @@ describe("a project's own preset, and the facts' other spellings", () => {
   it("a body size with no tolerance is not judged; a reference range with none is judged exactly", () => {
     expect(ids(house((f) => (f.body_pt = 12)))).toEqual([]);
     // 6.9 pt passes agenticdev (its body_pt_tol widens the range) and fails here, where nothing does.
-    expect(ids(house((f) => (f.ref_pt = 6.9)))).toEqual(["pdf/limits:refPt"]);
+    expect(ids(house((f) => (f.ref_pt = 6.9)))).toEqual([
+      "pdf/body-size:refPt",
+    ]);
   });
 
   it("facts naming the PDF by an absolute path are checked against that file", () => {
@@ -709,3 +1003,21 @@ describe("a project's own preset, and the facts' other spellings", () => {
     );
   });
 });
+
+describe("judgeBodyEnd, on a venue it does not apply to", () => {
+  const NO_TEXT = { pages: [], bibAnchorPage: null, appendixAnchorPage: null };
+  const venue = (kind: Resolved["kind"]): Resolved => ({
+    venue: "house",
+    format: { ...NO_FORMAT, bodyEndsAt: "references" },
+    kind,
+    kindProblem: null,
+    blind: false,
+    identity: null,
+  });
+
+  it("a kind with no body limit, or no kind: nothing to count against", () => {
+    const limits = { bodyPagesMax: null, refPagesMax: null };
+    expect(judgeBodyEnd(NO_TEXT, venue({ name: "long", limits }))).toEqual([]);
+    expect(judgeBodyEnd(NO_TEXT, venue(null))).toEqual([]);
+  });
+});