rvlib-shipkit 0.38.0 → 1.0.0

package/src/core/check-pass.ts

@@ -0,0 +1,84 @@
+// ONE PASS of the runner: the repo, its config, and what every check of the
+// pass shares. core/check-runner.ts builds one per `runChecks` call and hands it
+// to each check's context, so a shared scan runs once per pass and a new pass
+// runs it again, with no reset to remember.
+import { join } from 'path'
+import type { ScanCtx } from './check-ctx.ts'
+import { oidOnDisk, Reads } from './read-set.ts'
+import { rawAccessInClosure, rawAccessLine } from './raw-access.ts'
+import { RepoView } from '../ledger/repo-view.ts'
+import { loadConfig } from '../ts/config.ts'
+import { importClosure } from '../ts/source-graph.ts'
+import { LIB_ROOT } from './lib-root.ts'
+import type { RepoConfig } from '../repo-config.ts'
+import type { Scan } from '../scan.ts'
+
+/** a scan's context, and what it recorded while the scan ran */
+type ScanRecorder = ScanCtx & { readonly reads: Reads; readonly untracked: string | null }
+
+/** the config file every check that consults `c.config` depends on */
+export const CONFIG_FILE = 'repo.config.ts'
+
+export class CheckPass {
+    /** the run is report only: a check that rewrites the repo must not */
+    readonly frozen = process.env['SHIPKIT_FROZEN'] === '1'
+    /** the blob id of repo.config.ts as this pass loaded it, null = absent */
+    readonly configOid: string | null
+    private readonly scans = new Map<string, { value: Promise<unknown>; ctx: ScanRecorder }>()
+    private viewMemo: RepoView | null = null
+    private configMemo: { files: Map<string, string | null>; untracked: string | null } | null = null
+
+    constructor(
+        readonly root: string,
+        readonly config: RepoConfig,
+        /** where the file list comes from: the run's ledger shares its own,
+         *  so a listing and its validation read one snapshot */
+        private readonly openView: () => RepoView = () => RepoView.open(root),
+    ) {
+        this.configOid = oidOnDisk(join(root, CONFIG_FILE))
+    }
+
+    /** everything the config depends on: repo.config.ts as loaded and every
+     *  repo module it imports. One of those reaching the disk or a process
+     *  itself makes the config undescribable, and a check consulting it is
+     *  then never stored (core/raw-access.ts) */
+    configReads(): { files: ReadonlyMap<string, string | null>; untracked: string | null } {
+        if (this.configMemo != null) return this.configMemo
+        const files = new Map<string, string | null>([[CONFIG_FILE, this.configOid]])
+        let untracked: string | null = null
+        const skip = (f: string): boolean => f.split('/').includes('node_modules') || join(this.root, f).startsWith(`${LIB_ROOT}/`)
+        try {
+            const cfg = { ...loadConfig(this.root), root: this.root }
+            // what the config's LOAD runs: a literal `import()` inside a
+            // function it exports is not part of its value (core/raw-access.ts)
+            for (const f of importClosure(cfg, [CONFIG_FILE], { dynamic: false })) if (!files.has(f) && !skip(f)) files.set(f, oidOnDisk(join(this.root, f)))
+            const raw = rawAccessInClosure(this.root, join(this.root, CONFIG_FILE), { skip: LIB_ROOT, dynamic: false })
+            if (raw != null) untracked = `the config: ${rawAccessLine(raw)}`
+        } catch (e) {
+            untracked = `the modules repo.config.ts imports could not be listed (${String(e).slice(0, 120)})`
+        }
+        this.configMemo = { files, untracked }
+        return this.configMemo
+    }
+
+    view(): RepoView {
+        this.viewMemo ??= this.openView()
+        return this.viewMemo
+    }
+
+    /** the scan's value, started once per pass, and the reads it made. The
+     *  PROMISE is memoised, so two checks asking at once share one run.
+     *  `ctx` builds the context the scan reads through (core/check-ctx.ts). */
+    scan<T>(s: Scan<T>, ctx: () => ScanRecorder): { value: Promise<T>; ctx: ScanRecorder } {
+        let hit = this.scans.get(s.name)
+        if (hit == null) {
+            const c = ctx()
+            const value = (async () => await s.run(c))()
+            // a scan that throws fails each check that awaits it, and none other
+            value.catch(() => {})
+            hit = { value, ctx: c }
+            this.scans.set(s.name, hit)
+        }
+        return hit as { value: Promise<T>; ctx: ScanRecorder }
+    }
+}