eyeprolog 1.3.62 → 1.3.64

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.3.62",
+  "version": "1.3.64",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/test/run-all.mjs

@@ -23,6 +23,6 @@ await runStandalone(async (reporter) => {
   runCleanup(reporter);
   runRegression(reporter);
   await runPlayground(reporter);
-  runExamples(reporter);
+  await runExamples(reporter);
   runBookExamples(reporter);
 });

package/test/run-examples.mjs

@@ -2,8 +2,10 @@
 // Example-output test runner.
 // It compares examples byte-for-byte against golden output so answer and proof changes cannot silently alter results.
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { Program, run } from '../src/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule, runStandalone } from './test-style.mjs';
@@ -79,13 +81,13 @@ export const proofExamples = [
   'partial-evaluator.pl',
 ];
 
-export function runExamples(reporter = new TestReporter()) {
+export async function runExamples(reporter = new TestReporter()) {
   const files = fs.readdirSync(examplesDir)
     .filter((name) => exampleIsRunnable(name))
     .sort();
 
   reporter.section('Examples');
-  for (const name of files) reporter.test(name, () => runExample(name));
+  await runExampleTasks(files, (name, result) => reporter.testResult(name, result));
   reporter.sectionTotal('examples');
 
   reporter.section('Proof examples');
@@ -94,6 +96,101 @@ export function runExamples(reporter = new TestReporter()) {
 }
 
 
+async function runExampleTasks(tasks, onResult) {
+  if (tasks.length === 0) return;
+  const parallelism = os.availableParallelism?.() ?? os.cpus().length;
+  const workerCount = Math.min(tasks.length, Math.max(1, Math.min(3, parallelism - 1)));
+  if (workerCount === 1) {
+    for (const name of tasks) {
+      const startedAt = performance.now();
+      try {
+        runExample(name);
+        onResult(name, { ms: Math.round(performance.now() - startedAt) });
+      } catch (error) {
+        onResult(name, { ms: Math.round(performance.now() - startedAt), error });
+      }
+    }
+    return;
+  }
+
+  const completedResults = new Map();
+  let nextTask = 0;
+  let nextReport = 0;
+  let completed = 0;
+  let settled = false;
+
+  await new Promise((resolve, reject) => {
+    const workers = Array.from({ length: workerCount }, () => new Worker(new URL(import.meta.url), {
+      workerData: { exampleWorker: true },
+    }));
+
+    const stopWorkers = () => Promise.all(workers.map((worker) => worker.terminate()));
+
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      stopWorkers().finally(() => reject(error));
+    };
+
+    const finish = () => {
+      if (settled || completed !== tasks.length || nextReport !== tasks.length) return;
+      settled = true;
+      stopWorkers().then(() => resolve(), reject);
+    };
+
+    const reportReady = () => {
+      try {
+        while (completedResults.has(nextReport)) {
+          const result = completedResults.get(nextReport);
+          completedResults.delete(nextReport);
+          onResult(tasks[nextReport], result);
+          nextReport++;
+        }
+      } catch (error) {
+        fail(error);
+      }
+    };
+
+    const assign = (worker) => {
+      if (nextTask >= tasks.length || settled) return;
+      worker.postMessage({ id: nextTask, name: tasks[nextTask++] });
+    };
+
+    for (const worker of workers) {
+      worker.on('message', ({ id, ms, error }) => {
+        if (settled) return;
+        completedResults.set(id, {
+          ms,
+          error: error == null ? null : Object.assign(new Error(error.message), { stack: error.stack }),
+        });
+        completed++;
+        reportReady();
+        assign(worker);
+        finish();
+      });
+      worker.on('error', fail);
+      assign(worker);
+    }
+  });
+}
+
+function runExampleWorker() {
+  parentPort.on('message', ({ id, name }) => {
+    const startedAt = performance.now();
+    try {
+      runExample(name);
+      parentPort.postMessage({ id, ms: Math.round(performance.now() - startedAt), error: null });
+    } catch (error) {
+      parentPort.postMessage({
+        id,
+        ms: Math.round(performance.now() - startedAt),
+        error: { message: error?.message ?? String(error), stack: error?.stack ?? String(error) },
+      });
+    }
+  });
+}
+
+
 function exampleIsRunnable(name) {
   return name.endsWith('.pl');
 }
@@ -155,6 +252,8 @@ function diffText(expected, actualText) {
   return 'outputs differ';
 }
 
-if (isMainModule(import.meta.url)) {
+if (!isMainThread && workerData?.exampleWorker) {
+  runExampleWorker();
+} else if (isMainModule(import.meta.url)) {
   await runStandalone(runExamples);
 }

package/test/run-regression.mjs

@@ -2221,22 +2221,16 @@ c4 ?- call((!;1)).
     {
       name: 'REPL term input is on demand in conjunctions and Ctrl-D does not exit the top level',
       run: () => {
-        if (process.platform === 'win32') return;
-        const available = spawnSync('sh', ['-c',
-          'command -v script >/dev/null 2>&1 && script --version 2>/dev/null | grep -qi util-linux']);
-        if (available.status !== 0) return;
-        const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
-        const scriptCommand =
-          `{ printf 'read(X), read(Y).\n'; sleep 0.3; ` +
-          `printf 'foo.\n'; sleep 0.3; printf 'bar.\n'; sleep 0.3; ` +
-          `printf 'read(Z).\n'; sleep 0.3; printf '\\004'; sleep 0.3; ` +
-          `printf 'true.\n'; sleep 0.3; printf 'halt.\n'; } | ` +
-          `script -qefc ${shellQuote(command)} /dev/null`;
-        const result = spawnSync('sh', ['-c', scriptCommand], {
-          cwd: packageRoot,
-          encoding: 'utf8',
-          timeout: 5000,
-        });
+        if (!hasUtilLinuxScript()) return;
+        const result = runScriptedRepl([
+          { waitFor: '?- ', send: 'read(X), read(Y).\n' },
+          { waitFor: '  |: ', send: 'foo.\n' },
+          { waitFor: '|: ', send: 'bar.\n' },
+          { waitFor: 'X = foo, Y = bar.', send: 'read(Z).\n' },
+          { waitFor: '  |: ', send: '\u0004' },
+          { waitFor: 'Z = end_of_file.', send: 'true.\n' },
+          { waitFor: '   true.', send: 'halt.\n' },
+        ]);
         assertEqual(result.error?.code, undefined, 'interactive read timeout');
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout, 'X = foo, Y = bar.', 'conjunction reads');
@@ -2248,23 +2242,18 @@ c4 ?- call((!;1)).
     {
       name: 'REPL character input is on demand and Ctrl-D stays local (issue #55)',
       run: () => {
-        if (process.platform === 'win32') return;
-        const available = spawnSync('sh', ['-c',
-          'command -v script >/dev/null 2>&1 && script --version 2>/dev/null | grep -qi util-linux']);
-        if (available.status !== 0) return;
-        const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
-        const scriptCommand =
-          `{ printf 'peek_char(P), get_char(C), get_code(K).\n'; sleep 0.3; ` +
-          `printf 'ab\n'; sleep 0.3; printf 'get_char(N).\n'; sleep 0.3; ` +
-          `printf 'z\n'; sleep 0.3; printf 'get_char(E).\n'; sleep 0.3; ` +
-          `printf '\\004'; sleep 0.3; printf 'get_char(D).\n'; sleep 0.3; ` +
-          `printf 'q\n'; sleep 0.3; printf 'halt.\n'; } | ` +
-          `script -qefc ${shellQuote(command)} /dev/null`;
-        const result = spawnSync('sh', ['-c', scriptCommand], {
-          cwd: packageRoot,
-          encoding: 'utf8',
-          timeout: 5000,
-        });
+        if (!hasUtilLinuxScript()) return;
+        const result = runScriptedRepl([
+          { waitFor: '?- ', send: 'peek_char(P), get_char(C), get_code(K).\n' },
+          { waitFor: '  |: ', send: 'ab\n' },
+          { waitFor: 'P = a, C = a, K = 98.', send: 'get_char(N).\n' },
+          { waitFor: '  |: ', send: 'z\n' },
+          { waitFor: 'N = z.', send: 'get_char(E).\n' },
+          { waitFor: '  |: ', send: '\u0004' },
+          { waitFor: 'E = end_of_file.', send: 'get_char(D).\n' },
+          { waitFor: '  |: ', send: 'q\n' },
+          { waitFor: 'D = q.', send: 'halt.\n' },
+        ]);
         assertEqual(result.error?.code, undefined, 'interactive character input timeout');
         assertEqual(result.status, 0, 'exit status');
         assertIncludes(result.stdout, 'P = a, C = a, K = 98.', 'peek/get char and code input');
@@ -6112,6 +6101,99 @@ function shellQuote(value) {
   return `'${String(value).replaceAll("'", "'\"'\"'")}'`;
 }
 
+let utilLinuxScriptAvailable = null;
+
+function hasUtilLinuxScript() {
+  if (process.platform === 'win32') return false;
+  if (utilLinuxScriptAvailable == null) {
+    const available = spawnSync('sh', ['-c',
+      'command -v script >/dev/null 2>&1 && script --version 2>/dev/null | grep -qi util-linux']);
+    utilLinuxScriptAvailable = available.status === 0;
+  }
+  return utilLinuxScriptAvailable;
+}
+
+function runScriptedRepl(steps, { timeout = 5000 } = {}) {
+  const command = `${shellQuote(process.execPath)} ${shellQuote(bin)}`;
+  const payload = Buffer.from(JSON.stringify({
+    command,
+    cwd: packageRoot,
+    steps,
+    timeout,
+  })).toString('base64');
+  const helper = String.raw`
+const { spawn } = require('node:child_process');
+const config = JSON.parse(Buffer.from(process.env.EYEPROLOG_REPL_SCRIPT, 'base64').toString('utf8'));
+const child = spawn('script', ['-qefc', config.command, '/dev/null'], {
+  cwd: config.cwd,
+  stdio: ['pipe', 'pipe', 'pipe'],
+});
+let stdout = '';
+let stderr = '';
+let cursor = 0;
+let step = 0;
+let finished = false;
+
+function advance() {
+  while (step < config.steps.length) {
+    const current = config.steps[step];
+    const index = stdout.indexOf(current.waitFor, cursor);
+    if (index === -1) return;
+    cursor = index + current.waitFor.length;
+    child.stdin.write(current.send);
+    step++;
+  }
+}
+
+child.stdout.on('data', (chunk) => {
+  stdout += chunk;
+  advance();
+});
+child.stderr.on('data', (chunk) => {
+  stderr += chunk;
+});
+
+const timer = setTimeout(() => {
+  if (finished) return;
+  finished = true;
+  child.kill('SIGKILL');
+  process.stdout.write(JSON.stringify({ status: null, stdout, stderr, timedOut: true, step }));
+}, config.timeout);
+
+child.on('close', (status, signal) => {
+  if (finished) return;
+  finished = true;
+  clearTimeout(timer);
+  process.stdout.write(JSON.stringify({ status, signal, stdout, stderr, timedOut: false, step }));
+});
+`;
+  const helperResult = spawnSync(process.execPath, ['-e', helper], {
+    cwd: packageRoot,
+    encoding: 'utf8',
+    env: { ...process.env, EYEPROLOG_REPL_SCRIPT: payload },
+    timeout: timeout + 1000,
+  });
+  if (helperResult.error) return helperResult;
+  if (helperResult.status !== 0) return helperResult;
+  let result;
+  try {
+    result = JSON.parse(helperResult.stdout);
+  } catch (error) {
+    return {
+      ...helperResult,
+      error: new Error(`interactive REPL helper returned invalid JSON: ${error.message}`),
+    };
+  }
+  return {
+    status: result.status,
+    stdout: result.stdout,
+    stderr: `${result.stderr ?? ''}${helperResult.stderr ?? ''}`,
+    error: result.timedOut
+      ? Object.assign(new Error(`interactive REPL timed out after step ${result.step}`), { code: 'ETIMEDOUT' })
+      : undefined,
+  };
+}
+
 function runCli(args, options = {}) {
   return spawnSync(process.execPath, [bin, ...args], {
     cwd: packageRoot,

package/test/test-style.mjs

@@ -87,6 +87,21 @@ export class TestReporter {
     }
   }
 
+  testResult(name, { ms = 0, error = null } = {}) {
+    this.total++;
+    const nr = String(this.total).padStart(3, '0');
+
+    if (error == null) {
+      this.ok++;
+      this.stdout.write(`${colors.green}OK${colors.reset} ${nr} ${name} ${colors.dim}(${ms} ms)${colors.reset}\n`);
+      return;
+    }
+
+    this.stderr.write(`${colors.red}FAIL${colors.reset} ${nr} ${name} ${colors.dim}(${ms} ms)${colors.reset}\n`);
+    this.stderr.write(`${error?.stack ?? String(error)}\n`);
+    throw error;
+  }
+
   totalLine() {
     const ms = nowMs() - this.startedAt;
     this.stdout.write(`\n${colors.yellow}== Total${colors.reset}\n`);