eyeleng 1.0.6 → 1.0.7

package/test/shacl12-rules.test.js

@@ -1,24 +1,19 @@
 #!/usr/bin/env node
 'use strict';
 
-const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const path = require('node:path');
-const { colors: C, info, msTag, okLine, failLine, summaryLine } = require('./harness.js');
-
-const eyeleng = require('../src/index.js');
-const { tripleKey } = require('../src/term.js');
-
-const DEFAULT_MANIFEST = 'https://w3c.github.io/data-shapes/shacl12-test-suite/tests/rules/manifest-rules.ttl';
-const rootManifestUrl = process.env.EYELENG_SHACL12_RULES_MANIFEST || DEFAULT_MANIFEST;
-const fetchTimeoutMs = Number(process.env.EYELENG_SHACL12_FETCH_TIMEOUT_MS || 30000);
-const textCache = new Map();
-
-
-function isLikelyNetworkError(err) {
-  const msg = String(err && (err.stack || err.message || err));
-  return /fetch failed|ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ECONNRESET|network|timed out|GET .* failed/i.test(msg);
-}
+const { colors: C, info, summaryLine } = require('./harness.js');
+const {
+  defaultShacl12RulesManifestUrl,
+  isLikelyNetworkError,
+  isW3cRequired,
+  runShacl12RulesManifest,
+  formatShacl12RulesProgressLine,
+  writeShacl12RulesEarlReport,
+} = require('../src/shacl12RulesManifest.js');
+
+const rootManifestUrl = process.env.EYELENG_SHACL12_RULES_MANIFEST || defaultShacl12RulesManifestUrl;
 
 function appendSummary(summary) {
   const file = process.env.EYELENG_TEST_SUMMARY_FILE;
@@ -27,226 +22,53 @@ function appendSummary(summary) {
   fs.appendFileSync(file, `${JSON.stringify(summary)}\n`, 'utf8');
 }
 
-function stripHash(url) {
-  const parsed = new URL(url);
-  parsed.hash = '';
-  return parsed.href;
-}
-
-function resolveHref(baseUrl, href) {
-  return new URL(href, baseUrl).href;
-}
-
-async function fetchText(url) {
-  const normalized = stripHash(url);
-  if (textCache.has(normalized)) return textCache.get(normalized);
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), fetchTimeoutMs);
-  try {
-    const response = await fetch(normalized, { signal: controller.signal });
-    if (!response.ok) throw new Error(`GET ${normalized} failed: ${response.status} ${response.statusText}`);
-    const text = await response.text();
-    textCache.set(normalized, text.replace(/\r\n/g, '\n').replace(/\r/g, '\n'));
-    return textCache.get(normalized);
-  } catch (err) {
-    if (err && err.name === 'AbortError') throw new Error(`GET ${normalized} timed out after ${fetchTimeoutMs} ms`);
-    throw err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function parseIncludedManifests(rootUrl, text) {
-  const includeMatch = /mf:include\s*\(([\s\S]*?)\)\s*\./m.exec(text);
-  if (!includeMatch) throw new Error(`No mf:include list found in ${rootUrl}`);
-  return [...includeMatch[1].matchAll(/<([^>]+)>/g)].map((match) => resolveHref(rootUrl, match[1]));
-}
-
-function sectionName(manifestUrl) {
-  const pieces = new URL(manifestUrl).pathname.split('/').filter(Boolean);
-  if (pieces.length < 2) return manifestUrl;
-  return pieces[pieces.length - 2];
-}
-
-function manifestStatements(text) {
-  const statements = [];
-  const re = /([^\s;]+)\s+rdf:type\s+srt:([A-Za-z0-9]+)\s*;([\s\S]*?)\n\s*\./g;
-  let match;
-  while ((match = re.exec(text)) !== null) {
-    statements.push({ id: match[1], type: match[2], body: match[3] });
-  }
-  return statements;
-}
-
-function parseManifestTests(manifestUrl, text) {
-  const section = sectionName(manifestUrl);
-  const tests = [];
-
-  for (const statement of manifestStatements(text)) {
-    const name = /mf:name\s+"((?:[^"\\]|\\.)*)"/m.exec(statement.body)?.[1] || statement.id;
-
-    if (statement.type === 'RulesEvalTest') {
-      const ruleset = /srt:ruleset\s+<([^>]+)>/m.exec(statement.body)?.[1];
-      const data = /srt:data\s+<([^>]+)>/m.exec(statement.body)?.[1];
-      const result = /mf:result\s+<([^>]+)>/m.exec(statement.body)?.[1];
-      if (!ruleset || !data || !result) throw new Error(`Incomplete eval test ${statement.id} in ${manifestUrl}`);
-      tests.push({
-        section,
-        id: statement.id,
-        type: statement.type,
-        name,
-        manifestUrl,
-        rulesetUrl: resolveHref(manifestUrl, ruleset),
-        dataUrl: resolveHref(manifestUrl, data),
-        resultUrl: resolveHref(manifestUrl, result),
-      });
-      continue;
-    }
-
-    const action = /mf:action\s+<([^>]+)>/m.exec(statement.body)?.[1];
-    if (!action) throw new Error(`No mf:action found for ${statement.id} in ${manifestUrl}`);
-    tests.push({
-      section,
-      id: statement.id,
-      type: statement.type,
-      name,
-      manifestUrl,
-      actionUrl: resolveHref(manifestUrl, action),
-    });
-  }
-
-  return tests;
-}
-
-async function loadTests() {
-  const rootText = await fetchText(rootManifestUrl);
-  const manifestUrls = parseIncludedManifests(rootManifestUrl, rootText);
-  const suites = await Promise.all(manifestUrls.map(async (manifestUrl) => ({
-    manifestUrl,
-    text: await fetchText(manifestUrl),
-  })));
-  return suites.flatMap(({ manifestUrl, text }) => parseManifestTests(manifestUrl, text));
-}
-
-function shouldPass(type) {
-  return /Positive/.test(type) || type === 'RulesEvalTest';
-}
-
-async function runSyntaxOrWellformedTest(test) {
-  const source = await fetchText(test.actionUrl);
-  const options = { filename: test.actionUrl, baseIRI: test.actionUrl, shacl12Conformance: true };
-
-  if (test.type.includes('Syntax')) {
-    if (shouldPass(test.type)) eyeleng.parse(source, options);
-    else assert.throws(() => eyeleng.parse(source, options), Error);
-    return;
-  }
-
-  if (shouldPass(test.type)) eyeleng.compile(source, options);
-  else assert.throws(() => eyeleng.compile(source, options), Error);
-}
-
-async function parseTurtleTriples(url) {
-  const source = await fetchText(url);
-  return eyeleng.parseRdfDocument(source, { filename: url, baseIRI: url }).triples;
-}
-
-function sortedTripleKeys(triples) {
-  return triples.map(tripleKey).sort();
-}
-
-function setDiff(actual, expected) {
-  const actualSet = new Set(actual);
-  return expected.filter((item) => !actualSet.has(item));
-}
-
-async function runEvalTest(test) {
-  const [rulesSource, dataTriples, expectedTriples] = await Promise.all([
-    fetchText(test.rulesetUrl),
-    parseTurtleTriples(test.dataUrl),
-    parseTurtleTriples(test.resultUrl),
-  ]);
-
-  const compiled = eyeleng.compile(rulesSource, { filename: test.rulesetUrl, baseIRI: test.rulesetUrl, shacl12Conformance: true });
-  const program = { ...compiled.program, data: [...compiled.program.data, ...dataTriples] };
-  const result = eyeleng.evaluate(program, { analysis: compiled.analysis, shacl12Conformance: true });
-
-  const externalInput = new Set(dataTriples.map(tripleKey));
-  const actualTriples = result.closure.filter((triple) => !externalInput.has(tripleKey(triple)));
-  const actual = sortedTripleKeys(actualTriples);
-  const expected = sortedTripleKeys(expectedTriples);
-
-  try {
-    assert.deepEqual(actual, expected);
-  } catch (err) {
-    err.message += `\nMissing expected:\n${setDiff(actual, expected).join('\n')}\nUnexpected actual:\n${setDiff(expected, actual).join('\n')}`;
-    throw err;
-  }
-}
-
-async function runOne(test) {
-  if (test.type === 'RulesEvalTest') return runEvalTest(test);
-  return runSyntaxOrWellformedTest(test);
-}
-
 async function main() {
   const suiteStart = Date.now();
   info('W3C SHACL 1.2 Rules');
   console.log(`${C.dim}manifest: ${rootManifestUrl}${C.n}`);
 
-  let tests;
+  let result;
   try {
-    tests = await loadTests();
+    result = await runShacl12RulesManifest(rootManifestUrl, {
+      onProgress(item, index) {
+        console.log(formatShacl12RulesProgressLine(item, index, { colors: C }));
+      },
+    });
   } catch (err) {
-    if (isLikelyNetworkError(err) && process.env.EYELENG_W3C_REQUIRED !== '1') {
-      console.log(`${C.dim}W3C SHACL 1.2 Rules manifests not reachable here; set EYELENG_W3C_REQUIRED=1 to make this fatal.${C.n}`);
+    if (isLikelyNetworkError(err) && !isW3cRequired()) {
+      console.log(`${C.dim}W3C SHACL 1.2 Rules manifests not reachable; EYELENG_W3C_REQUIRED=0 permits this skip.${C.n}`);
       appendSummary({ section: 'W3C SHACL 1.2 Rules', passed: 1, failed: 0, total: 1, ms: Date.now() - suiteStart });
       return;
     }
-    failLine('---', 'load W3C SHACL 1.2 Rules manifests', Date.now() - suiteStart);
     console.error(err.stack || err.message || String(err));
     appendSummary({ section: 'W3C SHACL 1.2 Rules', passed: 0, failed: 1, total: 1, ms: Date.now() - suiteStart });
     process.exitCode = 1;
     return;
   }
 
-  const idxWidth = Math.max(3, String(Math.max(1, tests.length)).length);
-  let passed = 0;
-  let failed = 0;
-  const bySection = new Map();
-
-  for (let i = 0; i < tests.length; i++) {
-    const test = tests[i];
-    const idx = String(i + 1).padStart(idxWidth, '0');
-    const start = Date.now();
-    try {
-      await runOne(test);
-      okLine(idx, `${test.section}/${test.name}`, Date.now() - start);
-      passed++;
-      const section = bySection.get(test.section) || { passed: 0, failed: 0 };
-      section.passed++;
-      bySection.set(test.section, section);
-    } catch (err) {
-      failLine(idx, `${test.section}/${test.name}`, Date.now() - start);
-      console.error(err.stack || err.message || String(err));
-      failed++;
-      const section = bySection.get(test.section) || { passed: 0, failed: 0 };
-      section.failed++;
-      bySection.set(test.section, section);
-    }
+  try {
+    const reportPath = writeShacl12RulesEarlReport(result);
+    console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
+  } catch (err) {
+    console.error(`Failed to write SHACL Rules EARL report: ${err.message}`);
+    result.counts.fail += 1;
   }
 
-  const suiteMs = Date.now() - suiteStart;
-  for (const [section, counts] of bySection) {
-    const total = counts.passed + counts.failed;
-    summaryLine(counts.failed === 0 ? 'ok' : 'fail', counts.passed, total, null, { label: section });
+  for (const section of result.bySection) {
+    summaryLine(section.failed === 0 ? 'ok' : 'fail', section.passed, section.total, null, { label: section.section });
   }
-  summaryLine(failed === 0 ? 'ok' : 'fail', passed, tests.length, suiteMs);
+  summaryLine(result.counts.fail === 0 ? 'ok' : 'fail', result.counts.pass, result.counts.total, result.durationMs);
   console.log('');
 
-  appendSummary({ section: 'W3C SHACL 1.2 Rules', passed, failed, total: tests.length, ms: suiteMs });
-  if (failed > 0) process.exitCode = 1;
+  appendSummary({
+    section: 'W3C SHACL 1.2 Rules',
+    passed: result.counts.pass,
+    failed: result.counts.fail,
+    skipped: result.counts.skip,
+    total: result.counts.total,
+    ms: result.durationMs,
+  });
+  if (result.counts.fail > 0) process.exitCode = 1;
 }
 
 main().catch((err) => {

package/test/w3c-rdf.test.js

@@ -9,6 +9,7 @@ const {
   defaultW3cRdfManifestUrls,
   runW3cRdfManifests,
   formatW3cRdfProgressLine,
+  writeRdfEarlReport,
 } = require('../src/rdfManifest.js');
 const { parseNQuads, parseN3 } = require('../src/rdfSyntax.js');
 const { evaluateEntailmentTest, entails } = require('../src/rdfEntailment.js');
@@ -177,14 +178,16 @@ test('official W3C RDF manifests run with streaming progress when reachable', as
       },
     });
   } catch (err) {
-    if (isLikelyNetworkError(err) && process.env.EYELENG_W3C_REQUIRED !== '1') {
-      console.log(`${C.dim}W3C RDF manifests not reachable here; set EYELENG_W3C_REQUIRED=1 to make this fatal.${C.n}`);
+    if (isLikelyNetworkError(err) && process.env.EYELENG_W3C_REQUIRED === '0') {
+      console.log(`${C.dim}W3C RDF manifests not reachable; EYELENG_W3C_REQUIRED=0 permits this skip.${C.n}`);
       return;
     }
     throw err;
   }
   assert.equal(result.counts.fail, 0, `${result.counts.fail} W3C RDF failure(s)`);
   assert.ok(result.counts.pass > 0, 'expected at least one W3C RDF parser test to pass');
+  const reportPath = writeRdfEarlReport(result);
+  console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
   summaryLine('ok', result.counts.pass, result.counts.total, result.durationMs, {
     skipped: result.counts.skip,
     label: 'W3C RDF manifests',

package/tools/w3c-rdf.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
+const path = require('node:path');
 const { colors: C } = require('../test/harness.js');
 const {
   defaultW3cRdfManifestUrls,
@@ -8,13 +9,27 @@ const {
   formatW3cRdfProgressLine,
   formatW3cRdfManifestsResult,
   rdfManifestsToEarl,
+  writeRdfEarlReport,
+  defaultRdfReportPath,
 } = require('../src/rdfManifest.js');
 
+function argValue(argv, name) {
+  const index = argv.indexOf(name);
+  if (index < 0) return null;
+  return argv[index + 1] || null;
+}
+
 async function main(argv = process.argv.slice(2)) {
   const json = argv.includes('--json');
   const earl = argv.includes('--earl');
+  const noReport = argv.includes('--no-report');
   const quiet = json || earl || argv.includes('--quiet');
-  const manifests = argv.filter((arg) => !arg.startsWith('--'));
+  const output = argValue(argv, '--output') || defaultRdfReportPath();
+  const manifests = argv.filter((arg, index) => {
+    if (arg.startsWith('--')) return false;
+    if (argv[index - 1] === '--output') return false;
+    return true;
+  });
   const resources = manifests.length ? manifests : defaultW3cRdfManifestUrls;
   const result = await runW3cRdfManifests(resources, {
     onManifestStart(resource, index, total) {
@@ -24,6 +39,10 @@ async function main(argv = process.argv.slice(2)) {
       if (!quiet) console.log(formatW3cRdfProgressLine(item, index, { colors: C }));
     },
   });
+  if (!noReport) {
+    const reportPath = writeRdfEarlReport(result, output, { assertedBy: '<https://github.com/eyereasoner/eyeleng>' });
+    if (!quiet) console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
+  }
   if (json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
   else if (earl) process.stdout.write(`${rdfManifestsToEarl(result, { assertedBy: '<https://github.com/eyereasoner/eyeleng>' })}\n`);
   else process.stdout.write(`${formatW3cRdfManifestsResult(result, { colors: C })}\n`);

package/tools/w3c-shacl12-rules.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('node:path');
+const { colors: C } = require('../test/harness.js');
+const {
+  defaultShacl12RulesManifestUrl,
+  runShacl12RulesManifest,
+  formatShacl12RulesProgressLine,
+  formatShacl12RulesManifestResult,
+  shacl12RulesManifestToEarl,
+  writeShacl12RulesEarlReport,
+  defaultReportPath,
+} = require('../src/shacl12RulesManifest.js');
+
+function argValue(argv, name) {
+  const index = argv.indexOf(name);
+  if (index < 0) return null;
+  return argv[index + 1] || null;
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const json = argv.includes('--json');
+  const earl = argv.includes('--earl');
+  const noReport = argv.includes('--no-report');
+  const quiet = json || earl || argv.includes('--quiet');
+  const output = argValue(argv, '--output') || defaultReportPath();
+  const manifests = argv.filter((arg, index) => {
+    if (arg.startsWith('--')) return false;
+    if (argv[index - 1] === '--output') return false;
+    return true;
+  });
+  const manifest = manifests[0] || process.env.EYELENG_SHACL12_RULES_MANIFEST || defaultShacl12RulesManifestUrl;
+
+  const result = await runShacl12RulesManifest(manifest, {
+    onProgress(item, index) {
+      if (!quiet) console.log(formatShacl12RulesProgressLine(item, index, { colors: C }));
+    },
+  });
+
+  if (!noReport) {
+    const reportPath = writeShacl12RulesEarlReport(result, output);
+    if (!quiet) console.log(`${C.dim}EARL report: ${path.relative(path.join(__dirname, '..'), reportPath)}${C.n}`);
+  }
+
+  if (json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  else if (earl) process.stdout.write(`${shacl12RulesManifestToEarl(result)}\n`);
+  else process.stdout.write(`${formatShacl12RulesManifestResult(result, { colors: C })}\n`);
+  return result.counts.fail === 0 ? 0 : 1;
+}
+
+main().then((code) => { process.exitCode = code; }, (err) => {
+  console.error(err.stack || err.message || String(err));
+  process.exitCode = 1;
+});