eyeling 1.22.6 → 1.22.7

package/lib/cli.js

@@ -7,7 +7,11 @@
 
 'use strict';
 
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
 const engine = require('./engine');
+const deref = require('./deref');
 const { PrefixEnv } = require('./prelude');
 
 function offsetToLineCol(text, offset) {
@@ -50,6 +54,29 @@ function readTextFromStdinSync() {
   return fs.readFileSync(0, { encoding: 'utf8' });
 }
 
+function __isNetworkOrFileIri(s) {
+  return typeof s === 'string' && /^(https?:|file:\/\/)/i.test(s);
+}
+
+function __sourceLabelToBaseIri(sourceLabel) {
+  if (!sourceLabel || sourceLabel === '<stdin>') return '';
+  if (__isNetworkOrFileIri(sourceLabel)) return deref.stripFragment(sourceLabel);
+  return pathToFileURL(path.resolve(sourceLabel)).toString();
+}
+
+function __readInputSourceSync(sourceLabel) {
+  if (sourceLabel === '<stdin>') return readTextFromStdinSync();
+
+  if (__isNetworkOrFileIri(sourceLabel)) {
+    const txt = deref.derefTextSync(sourceLabel);
+    if (typeof txt !== 'string') throw new Error(`Failed to dereference ${sourceLabel}`);
+    return txt;
+  }
+
+  const fs = require('node:fs');
+  return fs.readFileSync(sourceLabel, { encoding: 'utf8' });
+}
+
 function main() {
   // Drop "node" and script name; keep only user-provided args
   // Expand combined short options: -pt == -p -t
@@ -163,13 +190,11 @@ function main() {
   }
 
   const sourceLabel = useImplicitStdin || positional[0] === '-' ? '<stdin>' : positional[0];
+  const baseIri = __sourceLabelToBaseIri(sourceLabel);
+
   let text;
   try {
-    if (sourceLabel === '<stdin>') text = readTextFromStdinSync();
-    else {
-      const fs = require('node:fs');
-      text = fs.readFileSync(sourceLabel, { encoding: 'utf8' });
-    }
+    text = __readInputSourceSync(sourceLabel);
   } catch (e) {
     if (sourceLabel === '<stdin>') console.error(`Error reading stdin: ${e.message}`);
     else console.error(`Error reading file ${JSON.stringify(sourceLabel)}: ${e.message}`);
@@ -181,6 +206,7 @@ function main() {
   try {
     toks = engine.lex(text);
     const parser = new engine.Parser(toks);
+    if (baseIri) parser.prefixes.setBase(baseIri);
     [prefixes, triples, frules, brules, qrules] = parser.parseDocument();
     // Make the parsed prefixes available to log:trace output (CLI path)
     engine.setTracePrefixes(prefixes);

package/lib/engine.js

@@ -199,21 +199,80 @@ function __isStrictGroundTriple(tr) {
 // -----------------------------------------------------------------------------
 // Used to maintain O(1) membership sets for dynamically promoted rules, and to
 // memoize per-firing head-blank skolemization.
+//
+// Important: variables and blank nodes *inside quoted formulas* are local to the
+// formula. Canonicalize those labels by first occurrence so alpha-equivalent
+// formulas (for example the repeated results of log:semantics after
+// standardize-apart) get the same identity key. Keep top-level blank labels
+// untouched so distinct existential witnesses in the global fact set do not
+// collapse together.
+function __keyFromTermForRuleIdentity(term) {
+  const ctx = { quotedVar: new Map(), quotedBlank: new Map() };
+
+  function canonQuotedVar(name) {
+    let out = ctx.quotedVar.get(name);
+    if (!out) {
+      out = `v${ctx.quotedVar.size}`;
+      ctx.quotedVar.set(name, out);
+    }
+    return out;
+  }
+
+  function canonQuotedBlank(label) {
+    let out = ctx.quotedBlank.get(label);
+    if (!out) {
+      out = `b${ctx.quotedBlank.size}`;
+      ctx.quotedBlank.set(label, out);
+    }
+    return out;
+  }
+
+  function enc(u, inQuotedFormula) {
+    if (u instanceof Iri) return ['I', u.value];
+    if (u instanceof Literal) return ['L', u.value];
+    if (u instanceof Blank) return inQuotedFormula ? ['BQ', canonQuotedBlank(u.label)] : ['B', u.label];
+    if (u instanceof Var) return inQuotedFormula ? ['VQ', canonQuotedVar(u.name)] : ['V', u.name];
+    if (u instanceof ListTerm) return ['List', u.elems.map((e) => enc(e, inQuotedFormula))];
+    if (u instanceof OpenListTerm) {
+      return [
+        'OpenList',
+        u.prefix.map((e) => enc(e, inQuotedFormula)),
+        inQuotedFormula ? ['TailVQ', canonQuotedVar(u.tailVar)] : ['TailV', u.tailVar],
+      ];
+    }
+    if (u instanceof GraphTerm)
+      return ['Graph', u.triples.map((tr) => [enc(tr.s, true), enc(tr.p, true), enc(tr.o, true)])];
+    return ['Other', String(u)];
+  }
+
+  return JSON.stringify(enc(term, false));
+}
+
 function __ruleKey(isForward, isFuse, premise, conclusion, dynamicConclusionTerm /* optional */) {
   let out = (isForward ? 'F' : 'B') + (isFuse ? '!' : '') + '|P|';
   for (let i = 0; i < premise.length; i++) {
     const tr = premise[i];
     if (i) out += '\n';
-    out += skolemKeyFromTerm(tr.s) + '\t' + skolemKeyFromTerm(tr.p) + '\t' + skolemKeyFromTerm(tr.o);
+    out +=
+      __keyFromTermForRuleIdentity(tr.s) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.p) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.o);
   }
   out += '|C|';
   for (let i = 0; i < conclusion.length; i++) {
     const tr = conclusion[i];
     if (i) out += '\n';
-    out += skolemKeyFromTerm(tr.s) + '\t' + skolemKeyFromTerm(tr.p) + '\t' + skolemKeyFromTerm(tr.o);
+    out +=
+      __keyFromTermForRuleIdentity(tr.s) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.p) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.o);
   }
   if (dynamicConclusionTerm) {
-    out += '|T|' + skolemKeyFromTerm(dynamicConclusionTerm);
+    out += '|T|' + __keyFromTermForRuleIdentity(dynamicConclusionTerm);
   }
   return out;
 }
@@ -224,7 +283,12 @@ function __firingKey(ruleIndex, instantiatedPremises) {
   for (let i = 0; i < instantiatedPremises.length; i++) {
     const tr = instantiatedPremises[i];
     if (i) out += '\n';
-    out += skolemKeyFromTerm(tr.s) + '\t' + skolemKeyFromTerm(tr.p) + '\t' + skolemKeyFromTerm(tr.o);
+    out +=
+      __keyFromTermForRuleIdentity(tr.s) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.p) +
+      '\t' +
+      __keyFromTermForRuleIdentity(tr.o);
   }
   return out;
 }
@@ -2464,7 +2528,17 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
       if (remaining <= 0) continue;
       const builtinMax = Number.isFinite(remaining) && !restGoals.length ? remaining : undefined;
 
-      let deltas = evalBuiltin(goal0, {}, facts, backRules, frame.curDepth, varGen, builtinMax);
+      const builtinGoalForEval = goalPredicateIri === LOG_NS + 'rawType' ? rawGoal : goal0;
+      const builtinSubstForEval = goalPredicateIri === LOG_NS + 'rawType' ? substMut : {};
+      let deltas = evalBuiltin(
+        builtinGoalForEval,
+        builtinSubstForEval,
+        facts,
+        backRules,
+        frame.curDepth,
+        varGen,
+        builtinMax,
+      );
 
       const dc = typeof frame.deferCount === 'number' ? frame.deferCount : 0;
       const builtinDeltasAreVacuous = deltas.length > 0 && deltas.every((d) => Object.keys(d).length === 0);

package/package.json

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

package/test/api.test.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const assert = require('node:assert/strict');
+const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 const ROOT = path.resolve(__dirname, '..');
@@ -2236,6 +2237,74 @@ _:x :hates { _:foo :making :mess }.
 `,
     expect: [/^:result\s+:is\s+\{[\s\S]*\?A\s+a\s+\?B\s*\.[\s\S]*\?B\s+rdfs:subClassOf\s+\?C\s*\.[\s\S]*\}\s*\./m],
   },
+  {
+    name: 'regression: log:rawType accepts quoted variables found via log:includes',
+    opt: { proofComments: false },
+    input: `@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix : <http://example.org/ns#> .
+
+{ ?X :likes ?Y } <= { ?X :loves ?Y }.
+
+{
+  ?X log:impliedBy ?Y .
+  ?X log:includes { ?Z1 :likes ?Z2 }.
+  ?Z1 log:rawType ?T.
+}
+=>
+{
+  :test :is true .
+}.
+`,
+    expect: [/^:test\s+:is\s+true\s*\./m],
+  },
+  {
+    name: 'regression: log:semantics body alpha-renaming does not refire blank-head rule forever',
+    async run() {
+      const os = require('node:os');
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeling-alpha-fire-'));
+      const mainPath = path.join(tmp, 'main.n3');
+      const examplePath = path.join(tmp, 'example.n3');
+
+      fs.writeFileSync(
+        mainPath,
+        `@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix : <urn:test#>.
+
+<> :facts <./example.n3> .
+
+{ ?X :load ?S } <= { <> :facts ?F . ?F log:semantics ?S . }.
+
+{ ?This :load ?S . } => { [] a :Test . }.
+`,
+        'utf8',
+      );
+
+      fs.writeFileSync(
+        examplePath,
+        `@prefix : <urn:test#>.
+{ ?A :p ?B } <= { ?A :q ?B }.
+`,
+        'utf8',
+      );
+
+      try {
+        const r = spawnSync(process.execPath, [path.join(ROOT, 'bin', 'eyeling.cjs'), mainPath], {
+          cwd: ROOT,
+          encoding: 'utf8',
+          maxBuffer: DEFAULT_MAX_BUFFER,
+          timeout: 5000,
+        });
+
+        if (r.error) throw r.error;
+        assert.equal(r.status, 0, r.stderr || `unexpected exit ${r.status}`);
+        mustOccurExactly(r.stdout, /^_:sk_\d+\s+a\s+:Test\s*\.$/gm, 1, 'expected exactly one derived :Test witness');
+        return r.stdout;
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    },
+  },
 ];
 
 let passed = 0;