paperlint 7.0.0 → 7.1.0

package/src/tex-venue-rules.ts

@@ -3,6 +3,7 @@
  * requires of the LaTeX itself, before any build:
  *
  *   tex/template          error  the `\documentclass` is the preset's class, with every option it names
+ *                                and none it forbids (`template_forbids`)
  *   tex/required-section  error  each section the preset requires is there, titled exactly, and
  *                                where the preset says (`last`: after every section of the body)
  *   tex/venue-leftover    warn   the text a reader sees names ANOTHER shipped venue — its `name`
@@ -107,20 +108,38 @@ type TemplateData = {
   readonly template: string;
 };
 
-/** A class line that names a class, against the template's: the same class, with every option. */
+/** What the template requires of a class line: its class and options, and the options it forbids. */
+interface Wanted {
+  readonly cls: DocumentClass;
+  readonly forbids: readonly string[];
+}
+
+/**
+ * A class line that names a class, against the template's: the same class, with every option, and
+ * none of the options the preset forbids.
+ */
 function judgeClass(
   line: Extract<ClassLine, { readonly kind: "class" }>,
-  want: DocumentClass,
+  want: Wanted,
   data: TemplateData,
 ): readonly Located[] {
   const at = spanOf(line.place);
-  if (line.cls !== want.cls)
+  if (line.cls !== want.cls.cls)
     return [{ messageId: "wrongClass", data: { ...data, got: line.cls }, at }];
-  return missingOptions(line, want).map((option) => ({
-    messageId: "missingOption",
-    data: { ...data, option },
-    at,
-  }));
+  const forbidden = want.forbids.filter((o) => line.options.includes(o));
+  const without = want.forbids.map((o) => `\`${o}\``).join(", ");
+  return [
+    ...forbidden.map((option) => ({
+      messageId: "forbiddenOption",
+      data: { ...data, option, without },
+      at,
+    })),
+    ...missingOptions(line, want.cls).map((option) => ({
+      messageId: "missingOption",
+      data: { ...data, option },
+      at,
+    })),
+  ];
 }
 
 /** A candidate as the message names it: its line, or an empty `\documentclass{}`. */
@@ -133,7 +152,7 @@ const candidateLine = (c: ClassCandidate): string =>
  */
 function judgeCandidates(
   candidates: readonly [ClassCandidate, ...ClassCandidate[]],
-  want: DocumentClass,
+  want: Wanted,
   data: TemplateData,
 ): readonly Located[] {
   const matches = candidates.some(
@@ -150,7 +169,7 @@ function judgeCandidates(
 /** The paper's class line against a template that was read: present, naming a class, that class. */
 function judgeClassLine(
   line: ClassLine,
-  want: DocumentClass,
+  want: Wanted,
   data: TemplateData,
 ): readonly Located[] {
   switch (line.kind) {
@@ -183,7 +202,7 @@ export function judgeTemplate(
     return [{ messageId: "badTemplate", data, at: null }];
   }
   const data = { venue: preset.label, template: documentClassLine(want) };
-  return judgeClassLine(line, want, data);
+  return judgeClassLine(line, { cls: want, forbids: t.forbids }, data);
 }
 
 /** Where a heading starts, or null when the parser gave it no place. */
@@ -248,8 +267,17 @@ export function judgeRequiredSections(
   );
 }
 
-/** Another shipped venue: the word for it, and what it is called in a paper's text. */
-export type OtherVenue = NamedVenue;
+/**
+ * Another shipped venue: the word for it, what it is called in a paper's text, and when a name
+ * counts as naming it (`mentions`).
+ */
+export type OtherVenue = NamedVenue & Pick<Preset, "mentions">;
+
+/**
+ * What must follow a name for it to name a `with-year` venue: a year beside it — `2027`, `'27` or
+ * `’27`, after spaces or none (`~` renders as a space). A lookahead, so the finding is the name.
+ */
+const YEAR_BESIDE = "(?=[\\s\\u00a0]*(?:\\d{4}|['’]\\d{2})(?![\\p{L}\\p{N}]))";
 
 /** `s` as a pattern that matches it literally. */
 const literal = (s: string): string =>
@@ -271,7 +299,7 @@ export function judgeLeftover(
       .map((alias) => ({
         other: o.label,
         re: new RegExp(
-          `(?<![\\p{L}\\p{N}])${literal(alias)}(?![\\p{L}\\p{N}])`,
+          `(?<![\\p{L}\\p{N}])${literal(alias)}(?![\\p{L}\\p{N}])${o.mentions === "with-year" ? YEAR_BESIDE : ""}`,
           "gu",
         ),
       })),
@@ -357,6 +385,8 @@ const RULES: Readonly<
           "the class is `{{got}}`, and {{venue}} requires `{{template}}` — the page size, fonts and layout the venue checks come from the class",
         missingOption:
           "the class option `{{option}}` is missing: {{venue}} requires `{{template}}`",
+        forbiddenOption:
+          "the class option `{{option}}` is forbidden: {{venue}} requires `{{template}}` without {{without}}",
         noCandidate:
           "none of the {{count}} \\documentclass lines is `{{template}}`, which {{venue}} requires: {{candidates}}. The source picks one behind a TeX switch, which is not evaluated; make one of them the venue's",
       },
@@ -442,7 +472,7 @@ export function otherVenues(
 ): readonly OtherVenue[] {
   return shippedVenueNames(deps)
     .filter((v) => !v.chain.every((f) => preset.chain.includes(f)))
-    .map(({ label, aliases }) => ({ label, aliases }));
+    .map(({ label, aliases, mentions }) => ({ label, aliases, mentions }));
 }
 
 /** What the venue-conformance rules are built with: the preset store, and the LaTeX reader. */

package/src/venue-rules.test.ts

@@ -239,13 +239,13 @@ describe("pdf/profile — the declaration must resolve, or nothing is judged", (
       "an unknown venue (a typo would silently disable every check)",
       { extends: "paperlint:agentic-dev", kind: "short" },
       "preset",
-      /agenticdev, aidc, aisec, ieee-conference, realm/,
+      /agenticdev, aidc, aisec, ieee-conference, msr, realm/,
     ],
     [
       "the base TeX set is not a venue",
       { extends: "paperlint:tex-base" },
       "preset",
-      /agenticdev, aidc, aisec, ieee-conference, realm/,
+      /agenticdev, aidc, aisec, ieee-conference, msr, realm/,
     ],
     [
       "paperlint.json that is not JSON",
@@ -863,6 +863,177 @@ describe("format/page-limit on AIDC: the two signals of where the references sta
   });
 });
 
+/**
+ * A project's own venue that counts its appendices in the body (`appendix_in_body`): a body of ten
+ * pages, appendices included, and two pages holding only references — MSR's rule.
+ */
+const OWN_APPENDIX_IN_BODY = {
+  [`${PAPER}/own.jsonc`]: JSON.stringify({
+    type: "venue",
+    name: "Own",
+    url: "https://example.org/cfp",
+    extends: "paperlint:ieee-conference",
+    format: {
+      body_ends_at: "references",
+      appendix_in_body: true,
+      kinds: {
+        technical: { body_pages_max: 10, ref_pages_max: 2 },
+        open: {},
+        refs: { ref_pages_max: 2 },
+      },
+    },
+  }),
+};
+
+/** `own.jsonc` papers of the kind named, over IEEE facts with `pages` and the two anchors. */
+const ownSplit = (
+  pages: readonly string[],
+  bib: number | null,
+  appendix: number | null,
+  kind = "technical",
+) =>
+  lint({
+    venue: { extends: "./own.jsonc", kind },
+    extra: OWN_APPENDIX_IN_BODY,
+    facts: ieeeFacts((f) => {
+      f.pages_text = [...pages];
+      f.bib_anchor_page = bib;
+      f.appendix_anchor_page = appendix;
+      // banal's counts, which this counting replaces: neither is judged.
+      f.body_pages = 99;
+      f.ref_pages = 99;
+    }),
+  });
+
+describe("format/page-limit with `appendix_in_body`: the appendix is body, the reference pages hold only references", () => {
+  const REFS = ["the end\nReferences\n[1] A.\n", "[2] B.\n", "[3] C.\n"];
+
+  it("ten pages of body and two of references pass; banal's counts are not judged", () => {
+    expect(ownSplit([...bodyPages(9), ...REFS], 10, null)).toEqual([]);
+  });
+
+  it("🔴 an appendix after the references that brings the body to eleven fails, naming where it starts", () => {
+    const fs = ownSplit(
+      [...bodyPages(9), ...REFS.slice(0, 2), "Appendix A.\nDetails\n"],
+      10,
+      12,
+    );
+    expect(fs.map((f) => f.message)).toEqual([
+      "body pages (up to the references on page 10, and the appendix from page 12): 11, over the limit 10 for Own/technical — a desk reject; cut the text",
+    ]);
+  });
+
+  it("🔴 three pages holding only references fail", () => {
+    const fs = ownSplit([...bodyPages(9), ...REFS, "[4] D.\n"], 10, null);
+    expect(fs.map((f) => f.message)).toEqual([
+      "pages holding only references: 3, over the limit 2 for Own/technical — a desk reject; cut the text",
+    ]);
+  });
+
+  it("an eleventh page of body before the references fails, appendices included", () => {
+    expect(ids(ownSplit([...bodyPages(10), ...REFS], 11, null))).toEqual([
+      "format/page-limit:pages",
+    ]);
+  });
+
+  it.each<
+    [string, readonly string[], readonly [number | null, number | null], string]
+  >([
+    [
+      "no references heading",
+      bodyPages(3),
+      [null, null],
+      "format/page-limit:noReferences",
+    ],
+    [
+      "an appendix anchor on a page with no «Appendix» line",
+      [...bodyPages(3), ...REFS],
+      [4, 6],
+      "format/page-limit:unclear",
+    ],
+  ])("%s: said, not counted", (_, pages, [bib, appendix], want) => {
+    expect(ids(ownSplit(pages, bib, appendix))).toEqual([want]);
+  });
+
+  it("a kind with no limits judges nothing; one with a reference limit only judges that", () => {
+    expect(ownSplit(bodyPages(3), null, null, "open")).toEqual([]);
+    expect(
+      ids(ownSplit([...bodyPages(12), ...REFS, "[4] D.\n"], 13, null, "refs")),
+    ).toEqual(["format/page-limit:pages"]);
+  });
+});
+
+/** An MSR technical paper that declares who wrote it. */
+const MSR = {
+  extends: "paperlint:msr",
+  kind: "technical",
+  identity: ["Ada Example"],
+};
+
+/** MSR facts: `pages` as the PDF's text, the two anchors where hyperref put them. */
+const msrFacts = (
+  pages: readonly string[],
+  bib: number,
+  appendix: number | null = null,
+) =>
+  ieeeFacts((f) => {
+    f.pages_text = [...pages];
+    f.bib_anchor_page = bib;
+    f.appendix_anchor_page = appendix;
+  });
+
+/** References that start below the last body text on their page, then `more` pages of them. */
+const refsFrom = (more: number): string[] => [
+  "the last lines of the conclusion\nR EFERENCES\n[1] D. E. Knuth.\n",
+  ...Array.from({ length: more }, (_, i) => `[${String(i + 2)}] More.\n`),
+];
+
+describe("format/page-limit on MSR: ten pages of main text, appendices included, and two of only references", () => {
+  it("🔴 ten pages of body, the references starting on the tenth, and two pages of only references pass", () => {
+    expect(
+      lint({
+        venue: MSR,
+        facts: msrFacts([...bodyPages(9), ...refsFrom(2)], 10),
+      }),
+    ).toEqual([]);
+  });
+
+  it("🔴 eleven pages of body fail", () => {
+    const fs = lint({
+      venue: MSR,
+      facts: msrFacts([...bodyPages(10), ...refsFrom(2)], 11),
+    });
+    expect(fs.map((f) => f.message)).toEqual([
+      "body pages (up to the references on page 11, appendices included): 11, over the limit 10 for MSR/technical — a desk reject; cut the text",
+    ]);
+  });
+
+  it("🔴 an appendix before the references that brings the body to eleven fails", () => {
+    const pages = [...bodyPages(9), "Appendix A.\nDetails\n", ...refsFrom(2)];
+    expect(ids(lint({ venue: MSR, facts: msrFacts(pages, 11, 10) }))).toEqual([
+      "format/page-limit:pages",
+    ]);
+  });
+
+  it("🔴 an appendix after the references that brings the body to eleven fails", () => {
+    const pages = [...bodyPages(9), ...refsFrom(1), "Appendix A.\nDetails\n"];
+    const fs = lint({ venue: MSR, facts: msrFacts(pages, 10, 12) });
+    expect(fs[0]?.message).toMatch(
+      /^body pages \(up to the references on page 10, and the appendix from page 12\): 11, over the limit 10/,
+    );
+  });
+
+  it("🔴 three pages of only references fail", () => {
+    const fs = lint({
+      venue: MSR,
+      facts: msrFacts([...bodyPages(9), ...refsFrom(3)], 10),
+    });
+    expect(fs.map((f) => f.message)).toEqual([
+      "pages holding only references: 3, over the limit 2 for MSR/technical — a desk reject; cut the text",
+    ]);
+  });
+});
+
 /** An AIDC paper that declares who wrote it. */
 const BLIND = {
   extends: "paperlint:aidc",

package/src/venue-rules.ts

@@ -58,7 +58,12 @@ import { fieldOf } from "./domain/record.ts";
 import type { Files } from "./ports/files.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
 import { findLeaks, type Leak, type Searchable } from "./domain/anonymity.ts";
-import { bodyEnd, type BodyEnd } from "./domain/body-pages.ts";
+import {
+  bodyEnd,
+  pageSplit,
+  type BodyEnd,
+  type PageSplit,
+} from "./domain/body-pages.ts";
 import type { TextFacts } from "./facts-file.ts";
 
 // ── the verdict's vocabulary ─────────────────────────────────────────────────────────
@@ -261,9 +266,19 @@ export function judgeGeometry(
   return out;
 }
 
+/**
+ * How many of banal's two counts — body, then references — a venue's counting replaces with its own
+ * from the text: none for banal's count, the body for `body_ends_at`, both with `appendix_in_body`.
+ */
+function countedFromText(format: VenueFormat): number {
+  if (format.bodyEndsAt !== "references") return 0;
+  return format.appendixInBody === true ? 2 : 1;
+}
+
 /**
  * Body and reference pages, as banal classifies them, against the kind's limits. A venue that counts
- * the body before the references is judged on its body by `judgeBodyEnd` instead.
+ * the body before the references is judged on its body by `judgeBodyEnd` instead, and one that
+ * counts the appendix as body on both.
  */
 export function judgePages(g: FlatGeometry, resolved: Resolved): Finding[] {
   const kind = resolved.kind;
@@ -272,7 +287,7 @@ export function judgePages(g: FlatGeometry, resolved: Resolved): Finding[] {
     [kind.limits.bodyPagesMax, g.body_pages, "body pages"],
     [kind.limits.refPagesMax, g.ref_pages, "reference pages"],
   ];
-  const from = resolved.format.bodyEndsAt === "references" ? 1 : 0;
+  const from = countedFromText(resolved.format);
   return pages.slice(from).flatMap(([max, got, what]) =>
     max !== null && got > max
       ? [
@@ -300,13 +315,11 @@ export function judgeBodyEnd(
   resolved: Resolved,
 ): readonly Finding[] {
   const kind = resolved.kind;
-  const max = kind?.limits.bodyPagesMax ?? null;
-  if (
-    resolved.format.bodyEndsAt !== "references" ||
-    kind === null ||
-    max === null
-  )
-    return [];
+  if (resolved.format.bodyEndsAt !== "references" || kind === null) return [];
+  if (resolved.format.appendixInBody === true)
+    return judgeSplit(text, resolved, kind);
+  const max = kind.limits.bodyPagesMax;
+  if (max === null) return [];
   const end = endOfBody(text);
   const venue = resolved.venue;
   switch (end.kind) {
@@ -324,6 +337,54 @@ export function judgeBodyEnd(
   }
 }
 
+/** The findings of a split that was found: the body, and the pages holding only references. */
+function splitFindings(
+  split: Extract<PageSplit, { readonly kind: "found" }>,
+  limits: KindLimits,
+  at: { readonly venue: string; readonly kind: string },
+): readonly Finding[] {
+  const refs = `the references on page ${String(split.page)}`;
+  const body =
+    split.appendixFrom === null
+      ? `body pages (up to ${refs}, appendices included)`
+      : `body pages (up to ${refs}, and the appendix from page ${String(split.appendixFrom)})`;
+  const counts: readonly [number | null, number, string][] = [
+    [limits.bodyPagesMax, split.bodyPages, body],
+    [limits.refPagesMax, split.refPages, "pages holding only references"],
+  ];
+  return counts.flatMap(([max, got, what]) =>
+    max !== null && got > max
+      ? [finding("pages", { what, got, max, ...at })]
+      : [],
+  );
+}
+
+/**
+ * The body, appendices included, and the pages holding only references (`appendix_in_body`),
+ * against the kind's two limits. Like `judgeBodyEnd`, an end it cannot find is said, not passed.
+ */
+function judgeSplit(
+  text: Pick<TextFacts, "pages" | "bibAnchorPage" | "appendixAnchorPage">,
+  resolved: Resolved,
+  kind: NonNullable<Resolved["kind"]>,
+): readonly Finding[] {
+  const limits = kind.limits;
+  if (limits.bodyPagesMax === null && limits.refPagesMax === null) return [];
+  const split = pageSplit(text.pages, {
+    bib: text.bibAnchorPage,
+    appendix: text.appendixAnchorPage,
+  });
+  const venue = resolved.venue;
+  switch (split.kind) {
+    case "missing":
+      return [finding("noReferences", { venue })];
+    case "disagree":
+      return [finding("unclear", { venue, why: disagreement(split) })];
+    case "found":
+      return splitFindings(split, limits, { venue, kind: kind.name });
+  }
+}
+
 /** Where the body ends in what the PDF says, and where hyperref anchored the two ends. */
 const endOfBody = (
   t: Pick<TextFacts, "pages" | "bibAnchorPage" | "appendixAnchorPage">,