@prestack/thread 0.1.2 → 0.1.4

package/dist/integrity/generators/trial.d.ts

@@ -1,7 +1,6 @@
 import type { Rule } from 'eslint';
 import type { Constraint, Sourced } from '../constraint.ts';
-import { type Byproduct, type Slopnator } from '../slopnator.ts';
-export declare const TRIALS_PATH: string;
+import { type Slopnator } from '../slopnator.ts';
 export interface Scenario {
     readonly files: readonly Sourced[];
     readonly at: string;
@@ -31,9 +30,10 @@ export interface Run {
     readonly passed: number;
     readonly failed: number;
     readonly measured: number;
+    readonly spent: ReadonlyMap<string, number>;
 }
 export declare function probeAt(rule: Constraint): string;
 export declare function deriveTrials(all: readonly Constraint[], slopnators: ReadonlyMap<string, Slopnator>): Derivation;
-export declare function trialsByproduct(derivation: Derivation): Byproduct;
 export declare function runTrial(trial: Trial, rule: Constraint, module: Rule.RuleModule, parser: unknown, slopnator?: Slopnator): Outcome;
+export declare function crossed(trials: readonly Trial[], all: readonly Constraint[], rules: Readonly<Record<string, Rule.RuleModule>>, parser: unknown, slopnators?: ReadonlyMap<string, Slopnator>, spent?: Map<string, number>): readonly Outcome[];
 export declare function runTrials(trials: readonly Trial[], all: readonly Constraint[], rules: Readonly<Record<string, Rule.RuleModule>>, parser: unknown, slopnators?: ReadonlyMap<string, Slopnator>): Run;

package/dist/integrity/generators/trial.js

@@ -1,14 +1,10 @@
-import * as disk from 'node:fs';
-import { answeredBy, existsSync, readFileSync } from "../../core/files.js";
-import { basename, dirname, join, resolve } from 'node:path';
-import { exit, invoked } from "../../core/invoked.js";
+import { answeredBy, standing } from '../../integrations/disk.js';
+import { resolve } from 'node:path';
 import { Linter } from 'eslint';
 const TREE = findTree();
-import { CONSTRAINTS } from "../constraint.js";
-import { NOT_WRITTEN, ROOT, governs, load, proofsOf, reads, rules, slopnatorName, sweeps, write } from "../slopnator.js";
-import { forget } from "../slopnators/sl_unthreaded.js";
-import { findTree } from "../../core/tree.js";
-export const TRIALS_PATH = `${findTree().name}/_generated/trials.ts`;
+import { NOT_WRITTEN, ROOT, governs, proofsOf, reads, slopnatorName, sweeps, visits } from '../slopnator.js';
+import { forget } from '../slopnators/sl_unthreaded.js';
+import { findTree } from '../../core/tree.js';
 const PROBE = 'probe.tsx';
 const WRAPPINGS = [
     (source) => source,
@@ -61,13 +57,6 @@ export function deriveTrials(all, slopnators) {
     }
     return { trials: trials.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) };
 }
-export function trialsByproduct(derivation) {
-    return {
-        path: TRIALS_PATH,
-        content: `export const RULE_TRIALS = ${JSON.stringify(derivation.trials, null, 2)} as const
-`,
-    };
-}
 function config(rule, module, parser) {
     return [
         {
@@ -81,91 +70,6 @@ function config(rule, module, parser) {
         },
     ];
 }
-const flat = (at) => (at.length > 1 && at.endsWith('/') ? at.replace(/\/+$/, '') : at);
-const under = (at) => at.startsWith(ROOT) || `${at}/` === ROOT;
-const own = (at) => under(at) && !at.slice(ROOT.length).split('/').includes('node_modules');
-function beside(at) {
-    try {
-        return disk.readdirSync(at, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-}
-function outside(at) {
-    const one = disk.statSync(at, { throwIfNoEntry: false });
-    if (one === undefined)
-        return 'none';
-    return one.isFile() ? 'file' : one.isDirectory() ? 'folder' : 'other';
-}
-const GONE = 'is not in the scenario this trial stands, and while it runs the scenario is the whole tree.';
-function answering(files) {
-    const held = new Map(files.map((one) => [resolve(ROOT, one.at), one.source]));
-    const folders = new Set();
-    const parents = (at) => {
-        for (let up = dirname(at); under(`${up}/`); up = dirname(up))
-            folders.add(up);
-    };
-    for (const at of held.keys())
-        parents(at);
-    const answers = {
-        kind: (at) => (held.has(at) ? 'file' : folders.has(at) ? 'folder' : own(at) ? 'none' : outside(at)),
-        read: (at) => {
-            const said = held.get(at);
-            if (said !== undefined)
-                return said;
-            if (own(at))
-                throw new Error(`${at} ${GONE}`);
-            return disk.readFileSync(at, 'utf8');
-        },
-        write: (at, said) => {
-            held.set(at, said);
-            parents(at);
-        },
-        list: (at) => {
-            const inside = new Map();
-            const found = own(at) ? [] : folders.has(at) ? beside(at) : disk.readdirSync(at, { withFileTypes: true });
-            for (const one of found)
-                inside.set(one.name, { name: one.name, kind: one.isDirectory() ? 'folder' : 'file' });
-            for (const path of folders)
-                if (dirname(path) === at)
-                    inside.set(basename(path), { name: basename(path), kind: 'folder' });
-            for (const path of held.keys())
-                if (dirname(path) === at)
-                    inside.set(basename(path), { name: basename(path), kind: 'file' });
-            return [...inside.values()];
-        },
-        stat: (at) => {
-            const said = held.get(at);
-            if (said !== undefined)
-                return { size: said.length, modified: 0 };
-            if (folders.has(at))
-                return { size: 0, modified: 0 };
-            if (own(at))
-                throw new Error(`${at} ${GONE}`);
-            const one = disk.statSync(at);
-            return { size: one.size, modified: one.mtimeMs };
-        },
-        remove: (at) => {
-            held.delete(at);
-            folders.delete(at);
-        },
-        real: (at) => (own(at) || held.has(at) || folders.has(at) ? at : disk.realpathSync(at)),
-    };
-    return {
-        kind: (at) => answers.kind(flat(at)),
-        read: (at) => answers.read(flat(at)),
-        write: (at, said) => {
-            answers.write(flat(at), said);
-        },
-        list: (at) => answers.list(flat(at)),
-        stat: (at) => answers.stat(flat(at)),
-        remove: (at) => {
-            answers.remove(flat(at));
-        },
-        real: (at) => answers.real(flat(at)),
-    };
-}
 export function runTrial(trial, rule, module, parser, slopnator) {
     const linter = new Linter();
     const failures = [];
@@ -181,7 +85,7 @@ export function runTrial(trial, rule, module, parser, slopnator) {
     const target = trial.scenario.files.find((file) => file.at === trial.scenario.at);
     let parsed = false;
     let satisfied = false;
-    answeredBy(answering(trial.scenario.files));
+    answeredBy(standing(ROOT, new Map(trial.scenario.files.map((one) => [resolve(ROOT, one.at), one.source]))));
     forget();
     try {
         if (slopnator !== undefined && !reads(slopnator)) {
@@ -230,8 +134,129 @@ export function runTrial(trial, rule, module, parser, slopnator) {
     }
     return { id: trial.id, rule: rule.id, passed: failures.length === 0, parsed, failures };
 }
+const judged = (who, rules, parser) => [
+    {
+        files: ['**/*.ts', '**/*.tsx'],
+        languageOptions: {
+            parser,
+            parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
+        },
+        plugins: { rule: { rules: Object.fromEntries(who.map((one) => [one.id, rules[one.id]])) } },
+        rules: Object.fromEntries(who.map((one) => ['rule/' + one.id, 'error'])),
+    },
+];
+const failed = (thrown) => 'could not run on it: ' + (thrown instanceof Error ? thrown.message : String(thrown));
+const parseable = (source, at, parser) => WRAPPINGS.find((wrap) => !new Linter().verify(wrap(source), judged([], {}, parser), at).some((one) => one.fatal === true)) ??
+    ((said) => said);
+function refusals(scenario, source, judges, rules, parser, slopnators) {
+    const found = new Map();
+    const note = (who, said) => {
+        const held = found.get(who) ?? new Set();
+        held.add(said);
+        found.set(who, held);
+    };
+    const walking = judges.filter((one) => {
+        const held = slopnators.get(slopnatorName(one.id));
+        return held !== undefined && visits(held) && rules[one.id] !== undefined;
+    });
+    const linted = (who) => {
+        const messages = new Linter().verify(source, judged(who, rules, parser), scenario.at);
+        if (messages.some((one) => one.fatal === true))
+            return;
+        for (const one of messages) {
+            const by = String(one.ruleId ?? '').replace('rule/', '');
+            if (by !== '')
+                note(by, one.message);
+        }
+    };
+    const files = scenario.files.map((one) => (one.at === scenario.at ? { at: one.at, source } : one));
+    answeredBy(standing(ROOT, new Map(files.map((one) => [resolve(ROOT, one.at), one.source]))));
+    forget();
+    try {
+        try {
+            linted(walking);
+        }
+        catch {
+            for (const one of walking) {
+                try {
+                    linted([one]);
+                }
+                catch (thrown) {
+                    note(one.id, failed(thrown));
+                }
+            }
+        }
+        for (const one of judges) {
+            const held = slopnators.get(slopnatorName(one.id));
+            if (held === undefined)
+                continue;
+            if (visits(held))
+                continue;
+            try {
+                if (sweeps(held)) {
+                    const said = held.holds(undefined, { filename: scenario.at, text: source, ancestors: () => [], comments: () => [] });
+                    if (said !== false && said !== NOT_WRITTEN)
+                        note(one.id, typeof said === 'string' ? said : slopnatorName(one.id));
+                    continue;
+                }
+                if (!reads(held))
+                    for (const said of held.checks(ROOT))
+                        note(one.id, said);
+            }
+            catch (thrown) {
+                note(one.id, failed(thrown));
+            }
+        }
+    }
+    finally {
+        answeredBy(undefined);
+        forget();
+    }
+    return found;
+}
+export function crossed(trials, all, rules, parser, slopnators = new Map(), spent = new Map()) {
+    const found = [];
+    const blanks = new Map();
+    for (const trial of trials) {
+        if (trial.verdict.reports)
+            continue;
+        const target = trial.scenario.files.find((one) => one.at === trial.scenario.at);
+        if (target === undefined)
+            continue;
+        const judges = all.filter((one) => governs(one, trial.scenario.at));
+        if (!judges.some((one) => one.id !== trial.rule))
+            continue;
+        const began = Date.now();
+        const wrap = parseable(target.source, trial.scenario.at, parser);
+        const emptied = JSON.stringify([wrap(''), trial.scenario.files.map((one) => (one.at === trial.scenario.at ? { at: one.at, source: '' } : one))]);
+        const blank = blanks.get(emptied) ?? refusals(trial.scenario, wrap(''), judges, rules, parser, slopnators);
+        blanks.set(emptied, blank);
+        const said = refusals(trial.scenario, wrap(target.source), judges, rules, parser, slopnators);
+        spent.set(trial.rule, (spent.get(trial.rule) ?? 0) + Date.now() - began);
+        for (const [who, messages] of said) {
+            if (who === trial.rule)
+                continue;
+            for (const message of messages) {
+                if (blank.get(who)?.has(message) === true)
+                    continue;
+                found.push({
+                    id: trial.id + '_under_' + who.replace(/-/g, '_'),
+                    rule: trial.rule,
+                    passed: false,
+                    parsed: true,
+                    failures: [
+                        'the form it recommends is refused by ' + who + ', so this law tells somebody to write what another law bans. ' +
+                            who + ' said: ' + (message.split('Found: ').pop() ?? message),
+                    ],
+                });
+            }
+        }
+    }
+    return found;
+}
 export function runTrials(trials, all, rules, parser, slopnators) {
     const byName = new Map(all.map((rule) => [rule.id, rule]));
+    const spent = new Map();
     const outcomes = trials.map((trial) => {
         const rule = byName.get(trial.rule);
         const module = rules[trial.rule];
@@ -241,72 +266,19 @@ export function runTrials(trials, all, rules, parser, slopnators) {
                 rule: trial.rule,
                 passed: false,
                 parsed: false,
-                failures: [`no rule named "${trial.rule}" is registered, so this trial is about nothing — regenerate with \`thread trials\``],
+                failures: [`the rule "${trial.rule}" has no slopnator on disk, so this trial is about nothing — the file to write is the one its row names in \`at\``],
             };
         }
-        return runTrial(trial, rule, module, parser, slopnators?.get(slopnatorName(rule.id)));
+        const began = Date.now();
+        const outcome = runTrial(trial, rule, module, parser, slopnators?.get(slopnatorName(rule.id)));
+        spent.set(trial.rule, (spent.get(trial.rule) ?? 0) + Date.now() - began);
+        return outcome;
     });
     return {
         outcomes,
         passed: outcomes.filter((outcome) => outcome.passed).length,
         failed: outcomes.filter((outcome) => !outcome.passed).length,
         measured: outcomes.filter((outcome) => outcome.parsed).length,
+        spent,
     };
 }
-if (invoked(import.meta.url)) {
-    const own = await rules();
-    const governing = own ?? CONSTRAINTS;
-    const source = own === undefined
-        ? `the ${String(CONSTRAINTS.length)} constraint(s) this tree authors`
-        : `the ${String(own.length)} rule(s) this tree declares — a shipped constraint is proved in the package that ships it, against the paths that package governs`;
-    const slopnators = await load(ROOT, governing);
-    const derivation = deriveTrials(governing, slopnators);
-    const byproduct = trialsByproduct(derivation);
-    if (process.argv.includes('--check')) {
-        const path = join(ROOT, byproduct.path);
-        const current = existsSync(path) ? readFileSync(path, 'utf8') : '';
-        const drifted = current !== byproduct.content;
-        if (drifted)
-            console.error(`trial: ${byproduct.path} is not what the rules derive. Run \`thread trials\` and commit the result.`);
-        console.log(`trial: ${String(derivation.trials.length)} derived from ${source}, ${String(drifted ? 1 : 0)} findings.`);
-        exit(drifted ? 1 : 0);
-    }
-    if (process.argv.includes('--try')) {
-        const at = process.argv.indexOf('--rule');
-        const only = at === -1 ? undefined : (process.argv[at + 1] ?? '').split(',').map((one) => one.trim()).filter(Boolean);
-        const unknown = (only ?? []).filter((id) => !governing.some((rule) => rule.id === id));
-        if (unknown.length > 0) {
-            console.error(`trial: no rule is called ${unknown.join(', ')} — a filter naming nothing would measure nothing and exit 0`);
-            exit(1);
-        }
-        const chosen = only === undefined ? derivation.trials : derivation.trials.filter((trial) => only.includes(trial.rule));
-        if (chosen.length === 0) {
-            if (only !== undefined) {
-                console.error('trial: the filter selected no trials, and measuring nothing must not exit 0');
-                exit(1);
-            }
-            if (governing.length > 0) {
-                console.error(`trial: ${String(governing.length)} rule(s) govern and none derived a trial — every rule owes a \`wrong\` and a \`right\`, so measuring nothing must not exit 0`);
-                exit(1);
-            }
-            console.log(`trial: nothing to prove — ${source}.`);
-            exit(0);
-        }
-        const { default: plugin } = await import("../lint.js");
-        const parser = (await import('typescript-eslint')).parser;
-        const run = runTrials(chosen, governing, plugin.rules, parser, slopnators);
-        for (const outcome of run.outcomes) {
-            if (outcome.passed)
-                continue;
-            for (const failure of outcome.failures)
-                console.error(`trial: ${outcome.id} — ${failure}`);
-        }
-        console.log(`trial: ${String(run.passed)} of ${String(run.outcomes.length)} passed, ${String(run.measured)} measured.`);
-        if (only !== undefined) {
-            console.log(`trial: PARTIAL RUN — ${String(derivation.trials.length - chosen.length)} of ${String(derivation.trials.length)} derived trials did not run. \`thread trials\` with no arguments runs every one.`);
-        }
-        exit(run.failed === 0 ? 0 : 1);
-    }
-    write(ROOT, byproduct);
-    console.log(`trial: wrote ${byproduct.path} — ${String(derivation.trials.length)} trials from ${source}.`);
-}