eyeling 1.15.0 → 1.15.1

package/examples/check/input/deep-taxonomy-100000.c

@@ -1,18 +1,95 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+
+enum { DEPTH = 100000 };
+
+static int emit(const char *s) {
+    return fputs(s, stdout) != EOF;
+}
+
+static int emit_type(const char *kind, int index) {
+    return printf(":ind a :%s%d .\n", kind, index) >= 0;
+}
 
 int main(void) {
-    if (printf("@prefix : <http://eulersharp.sourceforge.net/2009/12dtb/test#> .\n\n") < 0) {
+    unsigned char hasN[DEPTH + 1];
+    unsigned char hasI[DEPTH + 1];
+    unsigned char hasJ[DEPTH + 1];
+    unsigned char hasA2 = 0;
+    unsigned char hasTest = 0;
+    int changed = 1;
+
+    memset(hasN, 0, sizeof(hasN));
+    memset(hasI, 0, sizeof(hasI));
+    memset(hasJ, 0, sizeof(hasJ));
+
+    /* fact: :ind a :N0. */
+    hasN[0] = 1;
+
+    /*
+     * Forward-chain the rules to a fixpoint.
+     *
+     * {?X a :N0}      => {?X a :N1,      :I1,      :J1}.
+     * {?X a :N1}      => {?X a :N2,      :I2,      :J2}.
+     * ...
+     * {?X a :N99999}  => {?X a :N100000, :I100000, :J100000}.
+     * {?X a :N100000} => {?X a :A2}.
+     * {:ind a :A2}    => {:test :is true}.
+     */
+    while (changed) {
+        changed = 0;
+
+        for (int i = 0; i < DEPTH; i++) {
+            if (!hasN[i]) {
+                continue;
+            }
+
+            if (!hasN[i + 1]) {
+                hasN[i + 1] = 1;
+                changed = 1;
+            }
+            if (!hasI[i + 1]) {
+                hasI[i + 1] = 1;
+                changed = 1;
+            }
+            if (!hasJ[i + 1]) {
+                hasJ[i + 1] = 1;
+                changed = 1;
+            }
+        }
+
+        if (hasN[DEPTH] && !hasA2) {
+            hasA2 = 1;
+            changed = 1;
+        }
+
+        if (hasA2 && !hasTest) {
+            hasTest = 1;
+            changed = 1;
+        }
+    }
+
+    if (!emit("@prefix : <http://eulersharp.sourceforge.net/2009/12dtb/test#> .\n\n")) {
         return EXIT_FAILURE;
     }
 
-    for (int i = 1; i <= 100000; i++) {
-        if (printf(":ind a :N%d .\n:ind a :I%d .\n:ind a :J%d .\n", i, i, i) < 0) {
+    for (int i = 1; i <= DEPTH; i++) {
+        if (!hasN[i] || !hasI[i] || !hasJ[i]) {
+            fprintf(stderr, "incomplete closure at depth %d\n", i);
             return EXIT_FAILURE;
         }
+        if (!emit_type("N", i) || !emit_type("I", i) || !emit_type("J", i)) {
+            return EXIT_FAILURE;
+        }
+    }
+
+    if (!hasA2 || !hasTest) {
+        fputs("expected conclusions were not derived\n", stderr);
+        return EXIT_FAILURE;
     }
 
-    if (printf(":ind a :A2 .\n:test :is true .\n") < 0) {
+    if (!emit(":ind a :A2 .\n:test :is true .\n")) {
         return EXIT_FAILURE;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.15.0",
+  "version": "1.15.1",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/check.test.js

@@ -6,20 +6,36 @@ const os = require('node:os');
 const path = require('node:path');
 const cp = require('node:child_process');
 
-const TTY = process.stdout.isTTY;
-const C = TTY
-  ? { g: '\x1b[32m', r: '\x1b[31m', y: '\x1b[33m', dim: '\x1b[2m', n: '\x1b[0m' }
-  : { g: '', r: '', y: '', dim: '', n: '' };
-const msTag = (ms) => `${C.dim}(${ms} ms)${C.n}`;
+const C = process.stdout.isTTY
+  ? {
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    dim: '\x1b[2m',
+    reset: '\x1b[0m',
+  }
+  : {
+    red: '',
+    green: '',
+    yellow: '',
+    dim: '',
+    reset: '',
+  };
 
 function ok(msg) {
-  console.log(`${C.g}OK${C.n}  ${msg}`);
+  console.log(`${C.green}OK${C.reset} ${msg}`);
 }
+
 function fail(msg) {
-  console.error(`${C.r}FAIL${C.n} ${msg}`);
+  console.log(`${C.red}FAIL${C.reset} ${msg}`);
 }
+
 function info(msg) {
-  console.log(`${C.y}==${C.n} ${msg}`);
+  console.log(`${C.yellow}==${C.reset} ${msg}`);
+}
+
+function msTag(ms) {
+  return `(${ms} ms)`;
 }
 
 function run(cmd, args, opts = {}) {
@@ -33,8 +49,8 @@ function run(cmd, args, opts = {}) {
 function normalizeForCompare(n3Text) {
   return String(n3Text)
     .split(/\r?\n/)
-    .map((l) => l.replace(/[\t ]+$/g, ''))
-    .filter((l) => l.length > 0)
+    .map((line) => line.replace(/[ \t]+$/g, ''))
+    .filter((line) => line.length > 0)
     .sort((a, b) => a.localeCompare(b))
     .join('\n');
 }
@@ -77,7 +93,7 @@ function main() {
     .sort((a, b) => a.localeCompare(b));
 
   info(`Running ${files.length} C check tests`);
-  console.log(`${C.dim}compiler ${compiler}; node ${process.version}${C.n}`);
+  console.log(`${C.dim}compiler ${compiler}; node ${process.version}${C.reset}`);
 
   if (files.length === 0) {
     ok('No .c files found in examples/check/input/');
@@ -100,6 +116,8 @@ function main() {
     const tmpDir = mkTmpDir();
     const executablePath = path.join(tmpDir, stem + (process.platform === 'win32' ? '.exe' : ''));
 
+    let outFd = null;
+
     try {
       if (!fs.existsSync(expectedPath)) {
         throw new Error(`Missing expected output: ${path.relative(root, expectedPath)}`);
@@ -120,23 +138,32 @@ function main() {
         throw new Error(`Cannot run compiler '${compiler}': ${compile.error.message}`);
       }
       if (compile.status !== 0) {
-        throw new Error(`Compilation failed\n${compile.stderr || compile.stdout || ''}`.trim());
+        throw new Error(`Compilation failed\n${(compile.stderr || compile.stdout || '').trim()}`);
       }
 
-      const execResult = run(executablePath, [], { cwd: root });
+      outFd = fs.openSync(generatedPath, 'w');
+
+      const execResult = cp.spawnSync(executablePath, [], {
+        cwd: root,
+        stdio: ['ignore', outFd, 'pipe'],
+        encoding: 'utf8',
+      });
+
+      fs.closeSync(outFd);
+      outFd = null;
+
       if (execResult.error) {
         throw new Error(`Cannot run executable: ${execResult.error.message}`);
       }
-
-      fs.writeFileSync(generatedPath, execResult.stdout || '', 'utf8');
-
       if (execResult.status !== 0) {
-        throw new Error(`Executable exited with ${execResult.status}\n${execResult.stderr || ''}`.trim());
+        const why = execResult.signal ? `signal ${execResult.signal}` : `code ${execResult.status}`;
+        throw new Error(`Executable exited with ${why}\n${(execResult.stderr || '').trim()}`);
       }
 
       const expectedText = fs.readFileSync(expectedPath, 'utf8');
       const generatedText = fs.readFileSync(generatedPath, 'utf8');
       const same = normalizeForCompare(expectedText) === normalizeForCompare(generatedText);
+
       const ms = Date.now() - start;
 
       if (same) {
@@ -151,9 +178,14 @@ function main() {
     } catch (err) {
       const ms = Date.now() - start;
       fail(`${idx} ${file} ${msTag(ms)}`);
-      fail(err.message);
+      fail(err && err.message ? err.message : String(err));
       failed++;
     } finally {
+      if (outFd !== null) {
+        try {
+          fs.closeSync(outFd);
+        } catch {}
+      }
       rmrf(tmpDir);
     }
   }