eyeling 1.5.17 → 1.5.18

package/package.json

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

package/test/examples.test.js

@@ -15,16 +15,6 @@ function ok(msg)   { console.log(`${C.g}OK${C.n}  ${msg}`); }
 function fail(msg) { console.error(`${C.r}FAIL${C.n} ${msg}`); }
 function info(msg) { console.log(`${C.y}==${C.n} ${msg}`); }
 
-function padRight(s, n) {
-  s = String(s);
-  return s.length >= n ? s : (s + ' '.repeat(n - s.length));
-}
-
-function padLeft(s, n) {
-  s = String(s);
-  return s.length >= n ? s : (' '.repeat(n - s.length) + s);
-}
-
 function run(cmd, args, opts = {}) {
   return cp.spawnSync(cmd, args, {
     encoding: 'utf8',
@@ -44,8 +34,8 @@ function inGitWorktree(cwd) {
   return r.status === 0 && String(r.stdout).trim() === 'true';
 }
 
-// Expectation logic (same as bash version):
-// 1) If file contains a comment like: # expect-exit: 2  -> use that
+// Expectation logic:
+// 1) If file contains:  # expect-exit: N  -> use N
 // 2) Else, if it contains "=> false" -> expect exit 2
 // 3) Else -> expect exit 0
 function expectedExitCode(n3Text) {
@@ -57,25 +47,45 @@ function expectedExitCode(n3Text) {
 
 function getEyelingVersion(nodePath, eyelingJsPath, cwd) {
   const r = run(nodePath, [eyelingJsPath, '-v'], { cwd });
-  // eyeling prints version to stdout in your CLI
   const s = (r.stdout || r.stderr || '').trim();
   return s || 'eyeling (unknown version)';
 }
 
-function mkTmpFile() {
+function mkTmpDir() {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-examples-'));
-  const file = path.join(dir, 'generated.n3');
-  return { dir, file };
+  return dir;
 }
 
 function rmrf(p) {
   try { fs.rmSync(p, { recursive: true, force: true }); } catch {}
 }
 
+function showDiff({ IN_GIT, examplesDir, expectedPath, generatedPath, relExpectedPosix }) {
+  if (hasGit()) {
+    if (IN_GIT) {
+      // Show repo diff for the overwritten golden file
+      const d = run('git', ['diff', '--', relExpectedPosix], { cwd: examplesDir });
+      if (d.stdout) process.stdout.write(d.stdout);
+      if (d.stderr) process.stderr.write(d.stderr);
+    } else {
+      // Show no-index diff between packaged golden and generated tmp
+      const d = run('git', ['diff', '--no-index', expectedPath, generatedPath], { cwd: examplesDir });
+      // Replace tmp path in output (nice UX)
+      if (d.stdout) process.stdout.write(String(d.stdout).replaceAll(generatedPath, 'generated'));
+      if (d.stderr) process.stderr.write(String(d.stderr).replaceAll(generatedPath, 'generated'));
+    }
+  } else {
+    // Fallback: diff -u
+    const d = run('diff', ['-u', expectedPath, generatedPath], { cwd: examplesDir });
+    if (d.stdout) process.stdout.write(d.stdout);
+    if (d.stderr) process.stderr.write(d.stderr);
+  }
+}
+
 function main() {
   const suiteStart = Date.now();
 
-  // package root: .../test/examples.test.js -> root is one level up
+  // test/examples.test.js -> repo root is one level up
   const root = path.resolve(__dirname, '..');
   const examplesDir = path.join(root, 'examples');
   const outputDir = path.join(examplesDir, 'output');
@@ -83,107 +93,100 @@ function main() {
   const nodePath = process.execPath;
 
   if (!fs.existsSync(examplesDir)) {
-    fail(`Missing examples directory: ${examplesDir}`);
+    fail(`Cannot find examples directory: ${examplesDir}`);
     process.exit(1);
   }
   if (!fs.existsSync(eyelingJsPath)) {
-    fail(`Missing eyeling.js: ${eyelingJsPath}`);
+    fail(`Cannot find eyeling.js: ${eyelingJsPath}`);
     process.exit(1);
   }
 
   const IN_GIT = inGitWorktree(root);
 
-  // Header
-  console.log(`${C.y}-------------------------------------------------${C.n}`);
-  console.log(`${C.y}running eyeling examples${C.n}`);
-  console.log(
-    `${C.y}using ${getEyelingVersion(nodePath, eyelingJsPath, root)} and node ${process.version}${C.n}`
-  );
-  console.log(`${C.y}-------------------------------------------------${C.n}`);
-  console.log('');
-
-  // In maintainer mode we write expected outputs (tracked) to examples/output/
-  if (IN_GIT) fs.mkdirSync(outputDir, { recursive: true });
-
   const files = fs.readdirSync(examplesDir)
     .filter(f => f.endsWith('.n3'))
     .sort((a, b) => a.localeCompare(b));
 
+  info(
+    `Running ${files.length} examples tests (${IN_GIT ? 'git worktree mode' : 'npm-installed mode'})`
+  );
+  console.log(`${C.dim}${getEyelingVersion(nodePath, eyelingJsPath, root)}; node ${process.version}${C.n}`);
+
   if (files.length === 0) {
-    info('No .n3 files found in examples/');
+    ok('No .n3 files found in examples/');
     process.exit(0);
   }
 
-  let OK = 0;
-  let DIFF = 0;
+  // In maintainer mode we overwrite tracked goldens in examples/output/
+  if (IN_GIT) fs.mkdirSync(outputDir, { recursive: true });
 
-  for (const file of files) {
-    const filePath = path.join(examplesDir, file);
-    const expectedPath = path.join(outputDir, file); // examples/output/<file>
+  let passed = 0;
+  let failed = 0;
+
+  for (let i = 0; i < files.length; i++) {
+    const idx = String(i + 1).padStart(2, '0');
+    const file = files[i];
 
     const start = Date.now();
 
-    let n3Text = '';
+    const filePath = path.join(examplesDir, file);
+    const expectedPath = path.join(outputDir, file);
+    const relExpectedPosix = path.posix.join('output', file); // for git diff inside examplesDir
+
+    let n3Text;
     try {
       n3Text = fs.readFileSync(filePath, 'utf8');
     } catch (e) {
       const ms = Date.now() - start;
-      process.stdout.write(padRight(file, 36));
-      process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
-      console.log(`${C.r}DIFF${C.n} (cannot read input: ${e.message})`);
-      DIFF++;
+      fail(`${idx} ${file} (${ms} ms)`);
+      fail(`Cannot read input: ${e.message}`);
+      failed++;
       continue;
     }
 
     const expectedRc = expectedExitCode(n3Text);
 
-    // Decide where to write generated output
-    let tmp = null;
+    // Decide where generated output goes
+    let tmpDir = null;
     let generatedPath = expectedPath;
 
     if (!IN_GIT) {
       // npm-installed / no .git: never modify output/ in node_modules
       if (!fs.existsSync(expectedPath)) {
         const ms = Date.now() - start;
-        process.stdout.write(padRight(file, 36));
-        process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
-        console.log(`${C.r}MISSING expected output/${file}${C.n}`);
-        DIFF++;
+        fail(`${idx} ${file} (${ms} ms)`);
+        fail(`Missing expected output/${file}`);
+        failed++;
         continue;
       }
-      tmp = mkTmpFile();
-      generatedPath = tmp.file;
+      tmpDir = mkTmpDir();
+      generatedPath = path.join(tmpDir, 'generated.n3');
     }
 
-    // Run eyeling, capture exit code without aborting the suite
-    // We run `node eyeling.js <file>` from examplesDir so relative paths match old behavior.
+    // Run eyeling on this file (cwd examplesDir so relative behavior matches old script)
     const r = run(nodePath, [eyelingJsPath, file], { cwd: examplesDir });
     const rc = (r.status == null) ? 1 : r.status;
 
-    // Write stdout to the chosen output file (expected in git mode, tmp in npm mode)
+    // Write stdout to file (expectedPath in git mode; tmp in npm mode)
     try {
       fs.writeFileSync(generatedPath, r.stdout || '', 'utf8');
     } catch (e) {
       const ms = Date.now() - start;
-      process.stdout.write(padRight(file, 36));
-      process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
-      console.log(`${C.r}DIFF${C.n} (cannot write output: ${e.message})`);
-      DIFF++;
-      if (tmp) rmrf(tmp.dir);
+      fail(`${idx} ${file} (${ms} ms)`);
+      fail(`Cannot write output: ${e.message}`);
+      failed++;
+      if (tmpDir) rmrf(tmpDir);
       continue;
     }
 
     const ms = Date.now() - start;
 
-    // Compare outputs
+    // Compare output
     let diffOk = false;
-
     if (IN_GIT) {
-      // Compare expectedPath against HEAD using git diff
-      const d = run('git', ['diff', '--quiet', '--', path.posix.join('output', file)], { cwd: examplesDir });
+      const d = run('git', ['diff', '--quiet', '--', relExpectedPosix], { cwd: examplesDir });
       diffOk = (d.status === 0);
     } else {
-      // Compare expectedPath vs generatedPath without needing a repo
       if (hasGit()) {
         const d = run('git', ['diff', '--no-index', '--quiet', expectedPath, generatedPath], { cwd: examplesDir });
         diffOk = (d.status === 0);
@@ -193,49 +196,51 @@ function main() {
       }
     }
 
-    // Decide pass/fail
-    process.stdout.write(padRight(file, 36));
-    process.stdout.write(`${C.y}${padLeft(`${ms} ms`, 10)}${C.n} `);
+    const rcOk = (rc === expectedRc);
 
-    if (diffOk && rc === expectedRc) {
-      if (rc === 0) {
-        console.log(`${C.g}OK${C.n}`);
+    if (diffOk && rcOk) {
+      if (expectedRc === 0) {
+        ok(`${idx} ${file} (${ms} ms)`);
       } else {
-        console.log(`${C.g}OK${C.n} (exit ${rc})`);
+        ok(`${idx} ${file} (expected exit ${expectedRc}, ${ms} ms)`);
       }
-      OK++;
+      passed++;
     } else {
-      if (rc !== expectedRc) {
-        console.log(`${C.r}DIFF${C.n} (exit ${rc}, expected ${expectedRc})`);
-      } else {
-        console.log(`${C.r}DIFF${C.n}`);
+      fail(`${idx} ${file} (${ms} ms)`);
+      if (!rcOk) {
+        fail(`Exit code ${rc}, expected ${expectedRc}`);
       }
-      DIFF++;
-
-      // In npm mode, show a diff (nice UX) without modifying node_modules
-      if (!IN_GIT) {
-        if (hasGit()) {
-          const d = run('git', ['diff', '--no-index', expectedPath, generatedPath], { cwd: examplesDir });
-          if (d.stdout) process.stdout.write(d.stdout);
-          if (d.stderr) process.stderr.write(d.stderr);
-        } else {
-          const d = run('diff', ['-u', expectedPath, generatedPath], { cwd: examplesDir });
-          if (d.stdout) process.stdout.write(d.stdout);
-          if (d.stderr) process.stderr.write(d.stderr);
-        }
+      if (!diffOk) {
+        fail('Output differs');
       }
+
+      // Show diffs (both modes), because this is a test runner
+      showDiff({
+        IN_GIT,
+        examplesDir,
+        expectedPath,
+        generatedPath,
+        relExpectedPosix,
+      });
+
+      failed++;
     }
 
-    // cleanup tmp file
-    if (tmp) rmrf(tmp.dir);
+    if (tmpDir) rmrf(tmpDir);
   }
 
   console.log('');
   const suiteMs = Date.now() - suiteStart;
-  console.log(`${C.y}==${C.n} Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
-  console.log(`${C.y}==${C.n} ${C.g}${OK} OK${C.n}  ${C.r}${DIFF} DIFF${C.n}`);
+  info(`Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
 
-  process.exit(DIFF === 0 ? 0 : 2);
+  if (failed === 0) {
+    ok(`All examples tests passed (${passed}/${files.length})`);
+    process.exit(0);
+  } else {
+    fail(`Some examples tests failed (${passed}/${files.length})`);
+    // keep exit code 2 (matches historical behavior of examples/test)
+    process.exit(2);
+  }
 }
 
 main();