functionalscript 0.16.1 → 0.18.0

package/fs/dev/tf/module.f.js

@@ -3,9 +3,11 @@
  *
  * @module
  */
-import { fold } from "../../types/list/module.f.js";
-import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
-import { env, loadModuleMap } from "../module.f.js";
+import { reset, fgGreen, fgRed, bold, csiWrite } from "../../text/sgr/module.f.js";
+import { all, sandbox } from "../../types/effects/node/module.f.js";
+import { pure } from "../../types/effects/module.f.js";
+import { loadModuleMap } from "../module.f.js";
+import { invert } from "../../types/result/module.f.js";
 export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
@@ -18,24 +20,12 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export const parseTestSet = (t) => (throws) => (x) => {
+export const parseTestSet = (throws, x) => {
     switch (typeof x) {
         case 'function': {
             if (x.length === 0) {
-                const xt = x;
-                if (!throws && xt.name !== 'throw') {
-                    return xt;
-                }
-                // Pass-on-throw: the test passes if it throws. Triggered when the
-                // enclosing tree node is named 'throw' (so any function reference
-                // works, not only inline ones whose inferred name is 'throw').
-                return () => {
-                    const [tag, value] = t(xt);
-                    if (tag === 'ok') {
-                        throw value;
-                    }
-                    return value;
-                };
+                const fn = x;
+                return { fn, throws: throws || fn.name === 'throw' };
             }
             break;
         }
@@ -48,88 +38,135 @@ export const parseTestSet = (t) => (throws) => (x) => {
     }
     return [];
 };
-export const test = (input) => {
-    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
-    const isGitHub = env('GITHUB_ACTION') !== undefined;
-    const parse = parseTestSet(tryCatch);
-    const f = ([k, v]) => {
-        const test = i => throws => v => ([ts, state]) => {
-            const next = test(`${i}| `);
-            const set = parse(throws)(v);
-            if (typeof set === 'function') {
-                const [[s, r], delta, state0] = measure(() => tryCatch(set))(state);
-                state = state0;
-                if (s !== 'ok') {
-                    ts = addFail(delta)(ts);
-                    if (isGitHub) {
-                        // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                        error(`::error file=${k},line=1,title=${i}()::${r}`);
-                    }
-                    else {
-                        error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
-                        error(`${fgRed}${r}${reset}`);
+/**
+ * Recursively collects all leaf tests reachable from `v` as `[path, entry]`
+ * pairs, without running anything. Return-value sub-trees are not walked
+ * (that requires execution); only the static object/array/function structure
+ * is traversed.
+ */
+export const collectTests = (path, throws, v) => {
+    const set = parseTestSet(throws, v);
+    if (set instanceof Array) {
+        return set.flatMap(([ck, cv]) => collectTests([...path, ck], throws || ck === 'throw', cv));
+    }
+    return [[path, set]];
+};
+const mergeState = (a, b) => ({ time: a.time + b.time, pass: a.pass + b.pass, fail: a.fail + b.fail });
+const zero = { time: 0, pass: 0, fail: 0 };
+const runModule = ({ result, test }) => (k, v) => (ts) => {
+    const walk = (path, throws, v) => {
+        const effects = collectTests(path, throws, v)
+            .map(([testPath, set]) => test(k, testPath, set)
+            .step(sr => {
+            const { result: [s, r], duration } = sr;
+            return result(k, testPath, sr)
+                .step(() => {
+                if (s === 'ok') {
+                    if (set.throws) {
+                        return pure(addPass(duration)(zero));
                     }
+                    // Walk return-value sub-tree; null marks the call boundary so
+                    // paths render as e.g. `outer().inner`. throws resets to false.
+                    return walk([...testPath, null], false, r)
+                        .step(sub => pure(mergeState(addPass(duration)(zero), sub)));
                 }
-                else {
-                    ts = addPass(delta)(ts);
-                    log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
-                    // The result of a function is walked as a fresh sub-tree;
-                    // the parent's `throws` flag does not propagate into it.
-                    [ts, state] = next(false)(r)([ts, state]);
-                }
-            }
-            else {
-                const f = ([k, v]) => ([time, state]) => {
-                    log(`${i}${k}:`);
-                    [time, state] = next(throws || k === 'throw')(v)([time, state]);
-                    return [time, state];
-                };
-                [ts, state] = fold(f)([ts, state])(set);
-            }
-            return [ts, state];
-        };
-        return ([ts, state]) => {
-            if (isTest(k)) {
-                log(`testing ${k}`);
-                [ts, state] = test('| ')(false)(v.default)([ts, state]);
-                // Non-default exports are walked as a sibling test group so
-                // a test file can spread its tests across multiple named
-                // exports (see issue 27 in `issues/README.md`). Skip exports
-                // that parseTestSet would treat as empty (constants, types,
-                // non-test helpers) to avoid noisy empty entries in output.
-                const others = Object.fromEntries(Object.entries(v).filter(([key, val]) => key !== 'default' && ((typeof val === 'function' && val.length === 0) ||
-                    (typeof val === 'object' && val !== null))));
-                if (Object.keys(others).length !== 0) {
-                    [ts, state] = test('| ')(false)(others)([ts, state]);
-                }
-            }
-            return [ts, state];
-        };
+                return pure(addFail(duration)(zero));
+            });
+        }));
+        return all(...effects)
+            .step(states => pure(states.reduce(mergeState, zero)));
     };
-    let ts = { time: 0, pass: 0, fail: 0 };
-    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
-    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
-    log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`);
-    log(`${bold}Time: ${timeFormat(ts.time)}${reset}`);
-    return [ts.fail !== 0 ? 1 : 0, state];
+    return walk([], false, v)
+        .step(delta => pure(mergeState(ts, delta)));
+};
+const { entries } = Object;
+export const runModuleMap = (reporter) => (moduleMap) => {
+    const { summary } = reporter;
+    const modules = entries(moduleMap).filter(([k]) => isTest(k));
+    return modules.reduce((acc, [k, v]) => acc.step(runModule(reporter)(k, v)), pure({ time: 0, pass: 0, fail: 0 }))
+        .step(ts => summary(ts.pass, ts.fail, ts.time)
+        .step(() => pure(ts.fail !== 0 ? 1 : 0)));
 };
-export const anyLog = (f) => (s) => (state) => {
-    f(s);
-    return state;
+export const test = (reporter) => options => loadModuleMap(options.env).step(runModuleMap(reporter));
+const isAlpha = (c) => (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c === '_' || c === '$';
+const isDigit = (c) => c >= '0' && c <= '9';
+export const isInteger = (s) => s.length > 0 && [...s].every(isDigit) && (s === '0' || s[0] !== '0');
+export const isIdentifier = (s) => s.length > 0 && isAlpha(s[0]) && [...s.slice(1)].every(c => isAlpha(c) || isDigit(c));
+const fmtKey = (k) => k === null ? '()'
+    : isInteger(k) ? `[${k}]`
+        : isIdentifier(k) ? `.${k}`
+            : `[${JSON.stringify(k)}]`;
+/**
+ * Renders a key chain as a JS property-access expression: identifier keys use
+ * dot notation, integer keys use `[N]`, other strings use `["key"]`, and `null`
+ * emits `()` to mark a function-call boundary.
+ * E.g. `['math', 'add']` → `.math.add`, `['outer', null, 'inner']` → `.outer().inner`.
+ */
+export const fmtPath = (path) => path.reduce((acc, k) => acc + fmtKey(k), '');
+/**
+ * Formats a fully-qualified test identifier as a JS-like expression, e.g.
+ * `import("./math.test.f.ts").add()` or `import("./a.test.f.ts").users[3].name()`.
+ * Self-contained per line — suitable for parallel output and as a CLI filter argument.
+ */
+export const fmtImport = (file, path) => `import(${JSON.stringify(file)})${fmtPath(path)}()`;
+/**
+ * Renders a key chain for terminal output: `| ` per level of depth, followed
+ * by the last segment formatted as a bare integer, a bare identifier, or a
+ * JSON-quoted string. E.g. `['math', 'add']` → `| | add`,
+ * `['a', '0']` → `| | 0`, `['x', 'hello world']` → `| | "hello world"`.
+ */
+export const fmtTerm = (path) => {
+    const keys = path.flatMap(k => k !== null ? [k] : []);
+    const indent = '| '.repeat(keys.length);
+    if (keys.length === 0) {
+        return `${indent}()`;
+    }
+    const last = keys[keys.length - 1];
+    return `${indent}${isInteger(last) || isIdentifier(last) ? last : JSON.stringify(last)}`;
 };
-export const measure = (p) => (f) => (state) => {
-    const b = p.now();
-    const r = f();
-    const e = p.now();
-    return [r, e - b, state];
+/**
+ * Percent-encodes characters that GitHub workflow-command property values
+ * treat as separators (`%`, `:`, `,`) plus newlines.
+ * https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+ */
+export const ghEscape = (s) => s.replaceAll('%', '%25')
+    .replaceAll(':', '%3A')
+    .replaceAll(',', '%2C')
+    .replaceAll('\r', '%0D')
+    .replaceAll('\n', '%0A');
+export const defaultTest = (file, path, { fn, throws }) => sandbox(fn)
+    .step(r => pure(throws ? { ...r, result: invert(r.result) } : r));
+const fmtResultLine = (file, path, color, label, duration) => `${fmtImport(file, path)}: ${color}${label}${reset}, ${timeFormat(duration)}`;
+/**
+ * The terminal/GitHub reporter used by `fjs t`. Output goes through
+ * `csiWrite`, so ANSI styles are stripped on non-TTY streams. When
+ * `GITHUB_ACTION` is set, failures are emitted as `::error` workflow
+ * annotations instead of colored lines. Exported as a factory so the
+ * GitHub format path can be exercised directly from tests.
+ */
+export const defaultReporter = (options) => {
+    const write = csiWrite(options);
+    const line = (w) => {
+        const x = write(w);
+        return (s) => x(s + '\n');
+    };
+    const csiLog = line('stdout');
+    const csiError = line('stderr');
+    const isGitHub = options.env['GITHUB_ACTION'] !== undefined;
+    return {
+        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+        result: (file, path, { result: [s, v], duration }) => s === 'ok'
+            ? csiLog(fmtResultLine(file, path, fgGreen, 'ok', duration))
+            : isGitHub
+                ? csiError(`::error file=${file},line=1,title=${ghEscape(fmtImport(file, path))}::${ghEscape(String(v))}`)
+                : csiError(fmtResultLine(file, path, fgRed, 'error', duration))
+                    .step(() => csiError(`${fgRed}${v}${reset}`)),
+        summary: (pass, fail, time) => {
+            const fgFail = fail === 0 ? fgGreen : fgRed;
+            return csiLog(`${bold}Number of tests: pass: ${fgGreen}${pass}${reset}${bold}, fail: ${fgFail}${fail}${reset}${bold}, total: ${pass + fail}${reset}`)
+                .step(() => csiLog(`${bold}Time: ${timeFormat(time)}${reset}`));
+        },
+        test: defaultTest,
+    };
 };
-export const main = async (io) => test({
-    moduleMap: await loadModuleMap(io),
-    log: stdio(io), // anyLog(io.console.log),
-    error: stderr(io), // anyLog(io.console.error),
-    measure: measure(io.performance),
-    tryCatch: io.tryCatch,
-    env: env(io),
-    state: undefined,
-})[0];
+export const main = options => test(defaultReporter(options))(options);

package/fs/dev/tf/module.js

@@ -1,8 +1,12 @@
-import { io } from "../../io/module.js";
+import { io, tryCatch } from "../../io/module.js";
 import { loadModuleMap } from "../module.f.js";
-import { isTest, parseTestSet } from "./module.f.js";
+import { fmtImport, isTest, parseTestSet, runModuleMap } from "./module.f.js";
 import * as nodeTest from 'node:test';
 import { asyncImport } from "../../io/module.js";
+import { fromIo } from "../../io/module.f.js";
+import { pure } from "../../types/effects/module.f.js";
+import { asyncRun } from "../../types/effects/module.js";
+import {} from "../../types/effects/node/module.f.js";
 const isBun = typeof Bun !== 'undefined';
 const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
@@ -15,7 +19,6 @@ const createPlaywrightFramework = async () => {
 const framework = isPlaywright ? await createPlaywrightFramework() :
     isBun ? createBunFramework(nodeTest) :
         createFramework(nodeTest);
-const parse = parseTestSet(io.tryCatch);
 const scanModule = (x) => async (subTestRunner) => {
     let subTests = [x];
     while (true) {
@@ -26,28 +29,75 @@ const scanModule = (x) => async (subTestRunner) => {
         subTests = rest;
         //
         const [name, value, throws] = first;
-        const set = parse(throws)(value);
-        if (typeof set === 'function') {
-            await subTestRunner(name, () => {
-                const r = set();
-                // The result of a function is walked as a fresh sub-tree;
-                // the parent's `throws` flag does not propagate into it.
-                subTests = [...subTests, [`${name}()`, r, false]];
-            });
-        }
-        else {
+        const set = parseTestSet(throws, value);
+        if (set instanceof Array) {
             for (const [j, y] of set) {
                 const pr = `${name}/${j}`;
                 subTests = [...subTests, [pr, y, throws || j === 'throw']];
             }
         }
+        else {
+            await subTestRunner(name, () => {
+                if (set.throws) {
+                    let threw = false;
+                    try {
+                        set.fn();
+                    }
+                    catch (_) {
+                        threw = true;
+                    }
+                    if (!threw) {
+                        throw new Error(`${name}() expected to throw`);
+                    }
+                }
+                else {
+                    const r = set.fn();
+                    // The result of a function is walked as a fresh sub-tree;
+                    // the parent's `throws` flag does not propagate into it.
+                    subTests = [...subTests, [`${name}()`, r, false]];
+                }
+            });
+        }
     }
 };
+const noOp = () => pure(undefined);
+const reporter = {
+    result: noOp,
+    summary: noOp,
+    test: (file, path, { throws, fn }) => {
+        nodeTest.test(fmtImport(file, path), async (_t) => {
+            const [s, r] = tryCatch(fn);
+            if (throws === (s === 'ok')) {
+                throw r;
+            }
+            if (!throws) {
+                // TODO: add subtests
+            }
+        });
+        return pure({
+            result: ['ok', undefined],
+            duration: 0,
+        });
+    }
+};
+const map = {
+    // TODO: we use the same algorithm twice. Refactor by creating a `createAll(map)`
+    // helper that takes a `map` and returns an `all` function that runs effects
+    // according to the map. There could be a problem with circular dependencies,
+    // but we can use a lazy function `() => ToAsyncOperationMap<All>` instead od `map`.
+    all: async (...effects) => Promise.all(effects.map(asyncRun(map))),
+};
+export const run3 = async () => {
+    const fio = fromIo(io);
+    const moduleMap = await fio(loadModuleMap(io.process.env));
+    const runner = runModuleMap(reporter)(moduleMap);
+    await asyncRun(map)(runner);
+};
 export const run = async () => {
-    const x = await loadModuleMap(io);
-    for (const [i, v] of Object.entries(x)) {
+    const moduleMap = await fromIo(io)(loadModuleMap(io.process.env));
+    for (const [i, v] of Object.entries(moduleMap)) {
         if (isTest(i)) {
-            framework(i, scanModule(['', v.default, false]));
+            framework(i, scanModule(['', v, false]));
         }
     }
 };

package/fs/dev/tf/test.f.d.ts

@@ -1,21 +1,22 @@
-declare const _default: {
-    throw: () => never;
-    throwReference: {
-        throw: () => unknown;
-    };
-    throwGroup: {
-        throw: {
-            inline: () => never;
-            reference: () => unknown;
-            nested: {
-                deep: () => never;
-            };
-        };
-    };
-};
-export default _default;
-export declare const namedExportTest: () => void;
-export declare const namedExportGroup: {
-    nested: () => void;
-    throw: () => never;
+export declare const flat: () => void;
+export declare const nested: () => void;
+export declare const throwKey: () => void;
+export declare const throwKeyFail: () => void;
+export declare const mixedPassFail: () => void;
+export declare const returnValueSubTree: () => void;
+export declare const arrayKeys: () => void;
+export declare const nonTestFilesSkipped: () => void;
+export declare const multipleFiles: () => void;
+export declare const throwByFunctionName: () => void;
+export declare const namedExports: () => void;
+export declare const defaultReporterOutput: () => void;
+export declare const defaultReporterFailOutput: () => void;
+export declare const githubReporterOutput: () => void;
+export declare const helpers: {
+    isInteger: () => void;
+    isIdentifier: () => void;
+    fmtImport: () => void;
+    fmtPath: () => void;
+    fmtTerm: () => void;
+    ghEscape: () => void;
 };