paperlint 10.3.0 → 10.4.1

package/src/study-registry-rule.ts

@@ -18,6 +18,7 @@
  * file in `repro/`.
  */
 import { basename, dirname, join, posix } from "node:path";
+import { filter, map, pipe } from "remeda";
 import { callerPath } from "./caller-path.ts";
 import {
   README,
@@ -30,11 +31,16 @@ import {
   PLAN_NAME_PROBLEMS,
   STUDIES_FILE,
   judgeStudies,
-  planKeys,
+  folderKey,
+  planRefs,
+  studiesOf,
   studyMessage,
   type PlanState,
   type RegistryState,
+  type Study,
   type StudyFinding,
+  type Located,
+  type PlanRef,
 } from "./domain/study-registry.ts";
 import type { FolderLayoutDeps } from "./folder-layout-rule.ts";
 import type {
@@ -42,8 +48,11 @@ import type {
   FolderRuleModule,
 } from "./folder-venue-rule.ts";
 import type { Files } from "./ports/files.ts";
+import type { ListEntries } from "./ports/list-entries.ts";
 import type { StudyRegistryCodec } from "./ports/study-registry-codec.ts";
 import { reproEntriesOf } from "./repro-layout-rule.ts";
+import type { StudyFolder } from "./ports/study-folder.ts";
+import { studyFolder } from "./study-folder.ts";
 import { rulePageUrl } from "./venue-rules.ts";
 
 const STATUS_FILE = "PIPELINE-STATUS.md";
@@ -51,10 +60,12 @@ const STATUS_FILE = "PIPELINE-STATUS.md";
 /** What the rule reads with: the disk, its listings, and the registry's parser. */
 export interface StudyRegistryDeps extends FolderLayoutDeps {
   readonly codec: StudyRegistryCodec;
+  /** `repro/`'s entries, links not followed: a study folder that is a link is never read through. */
+  readonly entries: ListEntries;
 }
 
 /** The text of the file at `p`; null when there is none, or a directory sits there. */
-const textAt = (files: Files, p: string): string | null => {
+export const textAt = (files: Files, p: string): string | null => {
   const b = files.isFile(callerPath(p)) ? files.readBytes(callerPath(p)) : null;
   return b === null ? null : new TextDecoder().decode(b);
 };
@@ -83,61 +94,79 @@ const studyFolders = (dir: string, deps: FolderLayoutDeps): readonly string[] =>
     )
     .map((e) => e.name);
 
-/** Each `<folder>/<result_file>` of `r` that is a file. */
-const existingResults = (
-  dir: string,
+/** What each `<folder>/<result_file>` of `r`'s rows is, as the study folder's reader finds it. */
+const resultsOf = (
   r: RegistryState,
-  files: Files,
-): ReadonlySet<string> =>
-  new Set(
-    (r.kind === "read" ? r.registry.studies : [])
-      .flatMap((s) =>
-        s.result_file === undefined ? [] : [`${s.folder}/${s.result_file}`],
-      )
-      // A NUL is no path the disk can hold, and probing one throws: such a row reads as missing.
-      .filter(
-        (p) =>
-          !p.includes("\0") &&
-          files.isFile(callerPath(join(dir, REPRO_DIR, p))),
-      ),
+  folder: StudyFolder,
+): ReadonlyMap<string, Located> =>
+  pipe(
+    studiesOf(r),
+    filter(hasResultFile),
+    map(
+      (s) =>
+        [
+          folderKey(s.folder, s.result_file),
+          folder.locate(s.folder, s.result_file),
+        ] as const,
+    ),
+    (entries) => new Map(entries),
   );
 
+/** A row that names a result file. */
+const hasResultFile = (
+  s: Study,
+): s is Study & { readonly result_file: string } => s.result_file !== undefined;
+
 /**
  * The plan each row of `r` names, read and parsed, by `<folder>/<plan>`; a plan not there is left out.
  * A plan still named `prereg.json` is parsed by the loose schema of its old name.
  */
-const plansOf = (
-  dir: string,
+export const plansOf = (
   r: RegistryState,
-  deps: Pick<StudyRegistryDeps, "files" | "codec">,
+  folder: StudyFolder,
+  codec: StudyRegistryCodec,
 ): ReadonlyMap<string, PlanState> =>
   new Map(
-    (r.kind === "read" ? planKeys(r.registry) : [])
-      // A NUL is no path the disk can hold, and probing one throws: such a plan reads as missing.
-      .filter((key) => !key.includes("\0"))
-      .flatMap((key): readonly (readonly [string, PlanState])[] => {
-        const text = textAt(deps.files, join(dir, REPRO_DIR, key));
-        if (text === null) return [];
-        const parse =
-          posix.basename(key) === LEGACY_PLAN_FILE
-            ? deps.codec.parseLegacyPlan
-            : deps.codec.parsePlan;
-        return [[key, parse(text)]];
-      }),
+    (r.kind === "read" ? planRefs(r.registry) : []).flatMap((ref) => {
+      const state = planStateOf(ref, folder, codec);
+      return state === null
+        ? []
+        : [[folderKey(ref.folder, ref.plan), state] as const];
+    }),
   );
 
+/** The state of the plan `ref` names, read through `folder`; null when it is not there. */
+const planStateOf = (
+  { folder: of, plan, kind }: PlanRef,
+  folder: StudyFolder,
+  codec: StudyRegistryCodec,
+): PlanState | null => {
+  const read = folder.read(of, plan);
+  switch (read.kind) {
+    case "absent":
+      return null;
+    case "linked":
+      return { kind: "linked", link: read.link };
+    case "text":
+      return posix.basename(plan) === LEGACY_PLAN_FILE
+        ? codec.parseLegacyPlan(read.text)
+        : codec.parsePlan(read.text, kind);
+  }
+};
+
 /** Every finding of the paper folder `dir`'s study registry — THE function behind both rules. */
 export function studyFindings(
   dir: string,
   deps: StudyRegistryDeps,
 ): readonly StudyFinding[] {
   const registry = registryOf(dir, deps);
+  const folder = studyFolder(dir, deps);
   return judgeStudies({
     folders: studyFolders(dir, deps),
     registry,
     readme: textAt(deps.files, join(dir, REPRO_DIR, README)),
-    existingResults: existingResults(dir, registry, deps.files),
-    plans: plansOf(dir, registry, deps),
+    results: resultsOf(registry, folder),
+    plans: plansOf(registry, folder, deps.codec),
   });
 }
 

package/src/study-run.ts

@@ -0,0 +1,21 @@
+/** What a `paperlint studies` command on one study comes to: the lines it prints, or its refusal. */
+
+/** A refusal: the exit code, and the line that explains it. */
+export interface StudyRefusal {
+  readonly code: 1 | 2;
+  readonly line: string;
+}
+
+/** What a run came to: the lines it printed, or the refusal. */
+export type StudyRun =
+  | { readonly ok: true; readonly lines: readonly string[] }
+  | { readonly ok: false; readonly refusal: StudyRefusal };
+
+/** A refusal for the paper's state: exit 1. */
+export const refusal = (line: string): StudyRefusal => ({ code: 1, line });
+
+/** The run that is `r`. */
+export const refused = (r: StudyRefusal): StudyRun => ({
+  ok: false,
+  refusal: r,
+});