paperlint 5.0.0 → 6.1.0

package/src/tex-requirements.ts

@@ -28,6 +28,7 @@ import Ajv from "ajv";
 import { presetsDir } from "./package-dirs.ts";
 import { CONFIG_FILE } from "#lib/paper-config";
 import { fieldOf } from "./domain/record.ts";
+import type { RegisterAnchor, RegisterMeasureName } from "./domain/register.ts";
 
 /** CTAN package name → the names that prove it is installed. */
 export type PackageProofs = Readonly<Record<string, readonly string[]>>;
@@ -131,6 +132,8 @@ export interface VenueFormat {
   /** The prefix a font name of the body text starts with (`LinLibertine`). */
   readonly fontsText: string | null;
   readonly fontsTitle: string | null;
+  /** How the body is counted: null is banal's count; `references`, the pages before the references. */
+  readonly bodyEndsAt: "references" | null;
   readonly kinds: ReadonlyMap<string, KindLimits>;
 }
 
@@ -145,6 +148,7 @@ export const NO_FORMAT: VenueFormat = {
   refPtMax: null,
   fontsText: null,
   fontsTitle: null,
+  bodyEndsAt: null,
   kinds: new Map(),
 };
 
@@ -168,6 +172,8 @@ export interface PresetFile {
   readonly template: string | null;
   /** Other names the venue goes by in a paper's text; empty when the file names none. */
   readonly aliases: readonly string[];
+  /** Whether the venue reviews double-blind; null when the file does not say. */
+  readonly blind: boolean | null;
   /** Sections the venue requires; null when the file names none (a child's list replaces its parent's). */
   readonly requiredSections: readonly RequiredSection[] | null;
   /** Null when the file declares no `tex` block (allowed only with `extends`). */
@@ -175,6 +181,11 @@ export interface PresetFile {
   readonly format: VenueFormat;
   /** rule id → ESLint entry, checked against the shipped rules where a config is built. */
   readonly rules: Readonly<Record<string, unknown>>;
+  /**
+   * The accepted papers the register rules measure a body against; null when the file names none
+   * (a child's list replaces its parent's).
+   */
+  readonly registerAnchors: readonly RegisterAnchor[] | null;
 }
 
 type KindsJson = Readonly<
@@ -192,6 +203,7 @@ interface FormatJson {
   readonly ref_pt_max?: number;
   readonly fonts_text?: string;
   readonly fonts_title?: string;
+  readonly body_ends_at?: "references";
   readonly kinds?: KindsJson;
 }
 
@@ -201,6 +213,7 @@ interface PresetJson {
   readonly name?: string;
   readonly template?: string;
   readonly aliases?: readonly string[];
+  readonly blind?: boolean;
   readonly required_sections?: readonly {
     readonly title: string;
     readonly position?: "last";
@@ -210,6 +223,12 @@ interface PresetJson {
     Partial<Pick<TexRequirements, "tools">>;
   readonly format?: FormatJson;
   readonly rules?: Readonly<Record<string, unknown>>;
+  readonly register?: {
+    readonly anchors: readonly ({
+      readonly paper: string;
+      readonly words: number;
+    } & Readonly<Record<RegisterMeasureName, number>>)[];
+  };
 }
 
 /** An optional field as the typed preset holds it: absent is null. */
@@ -238,6 +257,7 @@ function formatOf(j: FormatJson = {}): VenueFormat {
     refPtMax: orNull(j.ref_pt_max),
     fontsText: orNull(j.fonts_text),
     fontsTitle: orNull(j.fonts_title),
+    bodyEndsAt: orNull(j.body_ends_at),
     kinds: kindsOf(j.kinds),
   };
 }
@@ -250,6 +270,38 @@ const sectionsOf = (
     ? null
     : r.map((x) => ({ title: x.title, position: orNull(x.position) }));
 
+/** A preset's JSONC text → its value, or an Error naming the syntax problem. */
+function jsoncOf(text: string, file: string): unknown {
+  const parsed = typescript().parseConfigFileTextToJson(file, text);
+  const config: unknown = parsed.config;
+  const error = parsed.error;
+  if (error)
+    throw new Error(
+      `${file}: not valid JSONC — ${typescript().flattenDiagnosticMessageText(error.messageText, " ")}`,
+    );
+  return config;
+}
+
+/** A preset's `tex` block, `tools` defaulted; null when the file declares none. */
+const texOf = (t: PresetJson["tex"]): TexRequirements | null =>
+  t ? { packages: t.packages, tools: t.tools ?? {} } : null;
+
+/** A preset's `register.anchors`, each with its counts; null when the file names none. */
+const anchorsOf = (
+  r: PresetJson["register"],
+): readonly RegisterAnchor[] | null =>
+  r === undefined
+    ? null
+    : r.anchors.map((a) => ({
+        paper: a.paper,
+        words: a.words,
+        counts: {
+          contrast_frames: a.contrast_frames,
+          claim_emphasis: a.claim_emphasis,
+          relation_markers: a.relation_markers,
+        },
+      }));
+
 /**
  * The text of one preset file → the typed file, or an Error naming every problem. The ONE parser
  * of a preset: the toolchain reads its `tex`, the venue rules its `format`, the config its `rules`.
@@ -263,13 +315,7 @@ export function parsePreset(
   file: string,
   dir: string = presetsDir(),
 ): PresetFile {
-  const parsed = typescript().parseConfigFileTextToJson(file, text);
-  const config: unknown = parsed.config;
-  const error = parsed.error;
-  if (error)
-    throw new Error(
-      `${file}: not valid JSONC — ${typescript().flattenDiagnosticMessageText(error.messageText, " ")}`,
-    );
+  const config = jsoncOf(text, file);
   const validate = validatorFor(dir);
   if (!matchesSchema(config, validate))
     throw new Error(
@@ -281,10 +327,12 @@ export function parsePreset(
     name: orNull(j.name),
     template: orNull(j.template),
     aliases: j.aliases ?? [],
+    blind: orNull(j.blind),
     requiredSections: sectionsOf(j.required_sections),
-    tex: j.tex ? { packages: j.tex.packages, tools: j.tex.tools ?? {} } : null,
+    tex: texOf(j.tex),
     format: formatOf(j.format),
     rules: j.rules ?? {},
+    registerAnchors: anchorsOf(j.register),
   };
 }
 

package/src/tex-venue-rules.test.ts

@@ -13,6 +13,8 @@ import {
   judgeRequiredSections,
   judgeTemplate,
   otherVenues,
+  FORMAT_RULE_LEVELS,
+  formatRules,
   TEX_VENUE_RULE_LEVELS,
   texVenueRules,
 } from "./tex-venue-rules.ts";
@@ -66,9 +68,15 @@ function lint(
     ...extra,
   });
   const out: Finding[] = [];
-  for (const [name, rule] of Object.entries(
-    texVenueRules({ files, venuesDir: VENUES, latex: latexReader }),
-  )) {
+  const deps = { files, venuesDir: VENUES, latex: latexReader };
+  for (const [id, rule] of [
+    ...Object.entries(texVenueRules(deps)).map(
+      ([n, r]) => [`tex/${n}`, r] as const,
+    ),
+    ...Object.entries(formatRules(deps)).map(
+      ([n, r]) => [`format/${n}`, r] as const,
+    ),
+  ]) {
     const visitor = rule.create({
       filename,
       sourceCode: {
@@ -78,7 +86,7 @@ function lint(
       },
       report: (d) =>
         out.push({
-          rule: `tex/${name}`,
+          rule: id,
           // A finding from an included file arrives as a whole message, its file at the front.
           messageId: "messageId" in d ? d.messageId : "(message)",
           message:
@@ -720,7 +728,7 @@ describe("otherVenues", () => {
 });
 
 describe("paperlint's own config", () => {
-  it.each(Object.entries(TEX_VENUE_RULE_LEVELS))(
+  it.each(Object.entries({ ...TEX_VENUE_RULE_LEVELS, ...FORMAT_RULE_LEVELS }))(
     "turns %s on at %s for every paper.tex, and ships it",
     (id, level) => {
       const tex = buildConfig({}, { sentinel: "tex" }).find((b) =>
@@ -738,4 +746,101 @@ describe("paperlint's own config", () => {
       "tex/venue-leftover": "warn",
     });
   });
+
+  it("format/layout-override is an error: the layout it guards is the template's", () => {
+    expect(FORMAT_RULE_LEVELS).toEqual({ "format/layout-override": "error" });
+  });
+});
+
+/** A conforming AIDC paper with `preamble` after its class line, and `body` before its statement. */
+const withPreamble = (preamble: string, body = "Text.") =>
+  paper(
+    `\\documentclass[conference,compsoc]{IEEEtran}\n${preamble}`,
+    `${body}\n\\section*{LLM Usage Statement}\nNone.`,
+  );
+const overrides = (tex: string, settings: object | undefined = AIDC) =>
+  lint(tex, settings).filter((f) => f.rule === "format/layout-override");
+
+describe("format/layout-override reports", () => {
+  it("each command that changes the template's layout, on its own line", () => {
+    const tex = withPreamble(
+      [
+        "\\usepackage[margin=1in]{geometry}",
+        "\\usepackage{amsmath,geometry}",
+        "\\setlength{\\textheight}{9.5in}",
+        "\\addtolength\\textwidth{1in}",
+        "\\setlength{\\columnsep}{0.1in}",
+        "\\linespread{0.95}",
+        "\\renewcommand{\\baselinestretch}{0.9}",
+        "\\geometry{left=1cm}",
+      ].join("\n"),
+      "Text.\n\\newgeometry{top=1cm}\nMore text.",
+    );
+    expect(
+      overrides(tex).map((f) => [f.line, f.message.split("`")[1]]),
+    ).toEqual([
+      [3, "\\usepackage{geometry}"],
+      [4, "\\usepackage{geometry}"],
+      [5, "\\setlength{\\textheight}"],
+      [6, "\\addtolength{\\textwidth}"],
+      [7, "\\setlength{\\columnsep}"],
+      [8, "\\linespread{0.95}"],
+      [9, "\\renewcommand{\\baselinestretch}"],
+      [10, "\\geometry"],
+      [13, "\\newgeometry"],
+    ]);
+    expect(overrides(tex)[0]?.message).toBe(
+      "`\\usepackage{geometry}` changes the page layout aidc's template sets (`\\documentclass[conference,compsoc]{IEEEtran}`) — a desk-reject reason at venues that check the format. Remove it; if the venue allows it, disable this line with a comment saying so",
+    );
+  });
+  it("a definition's body counts: the length it sets is set wherever it is used", () => {
+    const tex = withPreamble(
+      "\\newcommand{\\tall}{\\setlength{\\textheight}{10in}}",
+    );
+    expect(overrides(tex).map((f) => f.line)).toEqual([3]);
+  });
+});
+
+describe("format/layout-override stays silent", () => {
+  it("silent on what leaves the layout alone", () => {
+    const tex = withPreamble(
+      [
+        "\\usepackage{amsmath}",
+        "\\setlength{\\parindent}{0pt}",
+        "\\renewcommand{\\thesection}{\\arabic{section}}",
+        "% \\usepackage{geometry} in a comment",
+        "\\begin{comment}\\linespread{0.9}\\end{comment}",
+        // A length command with no arguments at all names no length.
+        "{\\setlength}",
+      ].join("\n"),
+      "A \\vspace{2mm} B \\vskip 3pt C \\vskip\\baselineskip D.",
+    );
+    expect(overrides(tex)).toEqual([]);
+  });
+
+  it("silent on local space pulled back: no venue's call names a negative skip", () => {
+    const tex = withPreamble(
+      "\\newcommand{\\tight}{\\vspace{-3pt}}",
+      "A \\vspace{-2mm} B \\vspace*{-1em} C \\vskip -3pt D.",
+    );
+    expect(lint(tex, AIDC)).toEqual([]);
+  });
+
+  it("silent without a preset, or with one that names no template", () => {
+    const tex = withPreamble("\\usepackage{geometry}");
+    expect(
+      lint(tex, undefined).filter((f) => f.rule === "format/layout-override"),
+    ).toEqual([]);
+    expect(overrides(tex, { extends: null })).toEqual([]);
+    const house = {
+      [`${PAPER}/house.jsonc`]: JSON.stringify({
+        tex: { packages: { ieeetran: ["IEEEtran.cls"] } },
+      }),
+    };
+    expect(
+      lint(tex, { extends: "./house.jsonc" }, { extra: house }).filter(
+        (f) => f.rule === "format/layout-override",
+      ),
+    ).toEqual([]);
+  });
 });

package/src/tex-venue-rules.ts

@@ -8,6 +8,13 @@
  *   tex/venue-leftover    warn   the text a reader sees names ANOTHER shipped venue — its `name`
  *                                or one of its `aliases` — than the one the paper extends
  *
+ * and, in the `format` plugin (named for the requirement, not the input — paperlint#151):
+ *
+ *   format/layout-override  error  the source changes the page layout the venue's template sets for
+ *                                  the whole document — margins, text block, line spacing
+ *
+ * The `format` plugin's other rule, `format/page-limit`, judges the built PDF (`venue-rules.ts`).
+ *
  * ── WHY THEY LIVE HERE AND NOT IN `eslint-rules/` ────────────────────────────────
  * Like the `pdf/*` venue rules (`venue-rules.ts`), they need the paper's resolved preset —
  * `paperPreset`, the one answer to "which venue is this paper judged against" — and read it through
@@ -32,6 +39,7 @@ import {
   type ClassLine,
   type DocumentClass,
   type Heading,
+  type LayoutOverride,
   type Outline,
   type Place,
   type Span,
@@ -290,7 +298,13 @@ export function judgeLeftover(
 
 /** Where a rule's page lives: `docs/rules/tex/<name>.md` on the default branch. */
 export const ruleDocsUrl = (
-  name: TexVenueRuleName | "claim-provenance" | "register",
+  name:
+    | TexVenueRuleName
+    | "claim-provenance"
+    | "register"
+    | "contrast-frames"
+    | "claim-emphasis"
+    | "relation-markers",
 ): string =>
   `https://github.com/zernie/paperlint/blob/main/docs/rules/tex/${name}.md`;
 
@@ -306,9 +320,26 @@ type Judge = (r: Reading) => readonly Located[];
 export type TexVenueRuleName =
   "template" | "required-section" | "venue-leftover";
 
+/** Every rule this module builds: the `tex` plugin's three and the `format` plugin's one. */
+type RuleName = TexVenueRuleName | "layout-override";
+
+/** Each layout override, where it stands. Silent for a preset that names no template. */
+export function judgeLayout(
+  overrides: readonly LayoutOverride[],
+  preset: Preset,
+): readonly Located[] {
+  const template = preset.template;
+  if (template === null) return [];
+  return overrides.map((o) => ({
+    messageId: "override",
+    data: { command: o.command, venue: preset.label, template: template.text },
+    at: spanOf(o.place),
+  }));
+}
+
 const RULES: Readonly<
   Record<
-    TexVenueRuleName,
+    RuleName,
     { readonly judge: Judge; readonly meta: TexRuleModule["meta"] }
   >
 > = {
@@ -357,6 +388,22 @@ const RULES: Readonly<
       },
     },
   },
+  "layout-override": {
+    judge: (r) => judgeLayout(r.latex.layoutOverrides(r.src), r.preset),
+    meta: {
+      type: "problem",
+      docs: {
+        description:
+          "the source changes the page layout the venue's template sets for the whole document: margins, text block, line spacing",
+        url: "https://github.com/zernie/paperlint/blob/main/docs/rules/format/layout-override.md",
+      },
+      schema: [],
+      messages: {
+        override:
+          "`{{command}}` changes the page layout {{venue}}'s template sets (`{{template}}`) — a desk-reject reason at venues that check the format. Remove it; if the venue allows it, disable this line with a comment saying so",
+      },
+    },
+  },
   "venue-leftover": {
     judge: (r) =>
       judgeLeftover(r.latex.renderedRuns(r.src), r.preset, r.others()),
@@ -385,6 +432,13 @@ export const TEX_VENUE_RULE_LEVELS: Readonly<
   "tex/venue-leftover": "warn",
 };
 
+/** The `format` plugin's rule over the source and its level, on for every `paper.tex`. */
+export const FORMAT_RULE_LEVELS: Readonly<
+  Record<"format/layout-override", "error">
+> = {
+  "format/layout-override": "error",
+};
+
 /**
  * Every shipped venue but the ones on this paper's own chain, each resolved the way a paper
  * extending it would be. A preset that does not resolve is skipped: `pdf/profile` owns that.
@@ -430,7 +484,7 @@ function readingOf(
   };
 }
 
-function rule(name: TexVenueRuleName, deps: TexVenueRuleDeps): TexRuleModule {
+function rule(name: RuleName, deps: TexVenueRuleDeps): TexRuleModule {
   const { judge, meta } = RULES[name];
   return {
     meta,
@@ -459,3 +513,10 @@ export function texVenueRules(
     "venue-leftover": rule("venue-leftover", deps),
   };
 }
+
+/** The `format` plugin's rule over the source (`page-limit`, over the PDF, is in `venue-rules.ts`). */
+export function formatRules(
+  deps: TexVenueRuleDeps,
+): Readonly<Record<"layout-override", TexRuleModule>> {
+  return { "layout-override": rule("layout-override", deps) };
+}

package/src/types.ts

@@ -26,6 +26,8 @@ export interface PaperlintConfig {
   kind?: string;
   /** The default path of the built PDF, relative to each paper. */
   pdf?: string;
+  /** What identifies the authors, for every paper (joined with a paper's own list). */
+  identity?: readonly string[];
   /** A note for humans; ignored. */
   $comment?: unknown;
 }