eyeling 1.5.32 → 1.5.34

package/examples/output/math-builtins-tests.n3

@@ -1,5 +1,6 @@
 @prefix : <http://example.org/math-tests#> .
 @prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
 
 # ----------------------------------------------------------------------
 # Proof for derived triple:
@@ -3431,16 +3432,16 @@
 # Proof for derived triple:
 #   :test-rounded-1 a :MathBuiltinTest .
 # It holds because the following instance of the rule body is provable:
-#   "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded 3 .
+#   "3.3"^^xsd:double math:rounded 3 .
 #   3 math:equalTo 3 .
 # via the schematic forward rule:
 #   {
-#     "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded ?r .
+#     "3.3"^^xsd:double math:rounded ?r .
 #     ?r math:equalTo 3 .
 #   } => {
 #     :test-rounded-1 a :MathBuiltinTest .
 #     :test-rounded-1 :builtin math:rounded .
-#     :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#     :test-rounded-1 :input "3.3"^^xsd:double .
 #     :test-rounded-1 :expected 3 .
 #     :test-rounded-1 :actual ?r .
 #     :test-rounded-1 :status :pass .
@@ -3456,16 +3457,16 @@
 # Proof for derived triple:
 #   :test-rounded-1 :builtin math:rounded .
 # It holds because the following instance of the rule body is provable:
-#   "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded 3 .
+#   "3.3"^^xsd:double math:rounded 3 .
 #   3 math:equalTo 3 .
 # via the schematic forward rule:
 #   {
-#     "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded ?r .
+#     "3.3"^^xsd:double math:rounded ?r .
 #     ?r math:equalTo 3 .
 #   } => {
 #     :test-rounded-1 a :MathBuiltinTest .
 #     :test-rounded-1 :builtin math:rounded .
-#     :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#     :test-rounded-1 :input "3.3"^^xsd:double .
 #     :test-rounded-1 :expected 3 .
 #     :test-rounded-1 :actual ?r .
 #     :test-rounded-1 :status :pass .
@@ -3479,18 +3480,18 @@
 
 # ----------------------------------------------------------------------
 # Proof for derived triple:
-#   :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#   :test-rounded-1 :input "3.3"^^xsd:double .
 # It holds because the following instance of the rule body is provable:
-#   "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded 3 .
+#   "3.3"^^xsd:double math:rounded 3 .
 #   3 math:equalTo 3 .
 # via the schematic forward rule:
 #   {
-#     "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded ?r .
+#     "3.3"^^xsd:double math:rounded ?r .
 #     ?r math:equalTo 3 .
 #   } => {
 #     :test-rounded-1 a :MathBuiltinTest .
 #     :test-rounded-1 :builtin math:rounded .
-#     :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#     :test-rounded-1 :input "3.3"^^xsd:double .
 #     :test-rounded-1 :expected 3 .
 #     :test-rounded-1 :actual ?r .
 #     :test-rounded-1 :status :pass .
@@ -3500,22 +3501,22 @@
 # Therefore the derived triple above is entailed by the rules and facts.
 # ----------------------------------------------------------------------
 
-:test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+:test-rounded-1 :input "3.3"^^xsd:double .
 
 # ----------------------------------------------------------------------
 # Proof for derived triple:
 #   :test-rounded-1 :expected 3 .
 # It holds because the following instance of the rule body is provable:
-#   "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded 3 .
+#   "3.3"^^xsd:double math:rounded 3 .
 #   3 math:equalTo 3 .
 # via the schematic forward rule:
 #   {
-#     "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded ?r .
+#     "3.3"^^xsd:double math:rounded ?r .
 #     ?r math:equalTo 3 .
 #   } => {
 #     :test-rounded-1 a :MathBuiltinTest .
 #     :test-rounded-1 :builtin math:rounded .
-#     :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#     :test-rounded-1 :input "3.3"^^xsd:double .
 #     :test-rounded-1 :expected 3 .
 #     :test-rounded-1 :actual ?r .
 #     :test-rounded-1 :status :pass .
@@ -3531,16 +3532,16 @@
 # Proof for derived triple:
 #   :test-rounded-1 :actual 3 .
 # It holds because the following instance of the rule body is provable:
-#   "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded 3 .
+#   "3.3"^^xsd:double math:rounded 3 .
 #   3 math:equalTo 3 .
 # via the schematic forward rule:
 #   {
-#     "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded ?r .
+#     "3.3"^^xsd:double math:rounded ?r .
 #     ?r math:equalTo 3 .
 #   } => {
 #     :test-rounded-1 a :MathBuiltinTest .
 #     :test-rounded-1 :builtin math:rounded .
-#     :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#     :test-rounded-1 :input "3.3"^^xsd:double .
 #     :test-rounded-1 :expected 3 .
 #     :test-rounded-1 :actual ?r .
 #     :test-rounded-1 :status :pass .
@@ -3556,16 +3557,16 @@
 # Proof for derived triple:
 #   :test-rounded-1 :status :pass .
 # It holds because the following instance of the rule body is provable:
-#   "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded 3 .
+#   "3.3"^^xsd:double math:rounded 3 .
 #   3 math:equalTo 3 .
 # via the schematic forward rule:
 #   {
-#     "3.3"^^<http://www.w3.org/2001/XMLSchema#double> math:rounded ?r .
+#     "3.3"^^xsd:double math:rounded ?r .
 #     ?r math:equalTo 3 .
 #   } => {
 #     :test-rounded-1 a :MathBuiltinTest .
 #     :test-rounded-1 :builtin math:rounded .
-#     :test-rounded-1 :input "3.3"^^<http://www.w3.org/2001/XMLSchema#double> .
+#     :test-rounded-1 :input "3.3"^^xsd:double .
 #     :test-rounded-1 :expected 3 .
 #     :test-rounded-1 :actual ?r .
 #     :test-rounded-1 :status :pass .

package/eyeling.js

@@ -34,6 +34,28 @@ const LIST_NS = "http://www.w3.org/2000/10/swap/list#";
 const LOG_NS = "http://www.w3.org/2000/10/swap/log#";
 const STRING_NS = "http://www.w3.org/2000/10/swap/string#";
 const SKOLEM_NS = "https://eyereasoner.github.io/.well-known/genid/";
+const RDF_JSON_DT = RDF_NS + "JSON";
+
+function isRdfJsonDatatype(dt) {
+  // dt comes from literalParts() and may be expanded or prefixed depending on parsing/printing.
+  return dt === null || dt === RDF_JSON_DT || dt === "rdf:JSON";
+}
+
+function termToJsonText(t) {
+  if (!(t instanceof Literal)) return null;
+  const [lex, dt] = literalParts(t.value);
+  if (!isRdfJsonDatatype(dt)) return null;
+  // decode escapes for short literals; long literals are taken verbatim
+  return termToJsStringDecoded(t);
+}
+
+function makeRdfJsonLiteral(jsonText) {
+  // Prefer a readable long literal when safe; fall back to short if needed.
+  if (!jsonText.includes('"""')) {
+    return new Literal('"""' + jsonText + '"""^^<' + RDF_JSON_DT + '>');
+  }
+  return new Literal(JSON.stringify(jsonText) + '^^<' + RDF_JSON_DT + '>');
+}
 
 // For a single reasoning run, this maps a canonical representation
 // of the subject term in log:skolem to a Skolem IRI.
@@ -552,6 +574,9 @@ function collectIrisInTerm(t) {
   const out = [];
   if (t instanceof Iri) {
     out.push(t.value);
+  } else if (t instanceof Literal) {
+    const [_lex, dt] = literalParts(t.value);
+    if (dt) out.push(dt); // so rdf/xsd prefixes are emitted when only used in ^^...
   } else if (t instanceof ListTerm) {
     for (const x of t.elems) out.push(...collectIrisInTerm(x));
   } else if (t instanceof OpenListTerm) {
@@ -1842,91 +1867,6 @@ function termToJsStringDecoded(t) {
   return stripQuotes(lex);
 }
 
-function _jsonPointerUnescape(seg) {
-  // RFC6901: ~1 -> '/', ~0 -> '~'
-  // Any other '~' escape is invalid.
-  let out = "";
-  for (let i = 0; i < seg.length; i++) {
-    const c = seg[i];
-    if (c !== "~") { out += c; continue; }
-    if (i + 1 >= seg.length) return null;
-    const n = seg[i + 1];
-    if (n === "0") out += "~";
-    else if (n === "1") out += "/";
-    else return null;
-    i++;
-  }
-  return out;
-}
-
-function _jsonToTerm(v) {
-  if (v === null) return makeStringLiteral("null");
-  if (typeof v === "string") return makeStringLiteral(v);
-  if (typeof v === "number") return new Literal(String(v));
-  if (typeof v === "boolean") return new Literal(v ? "true" : "false");
-  if (Array.isArray(v)) return new ListTerm(v.map(_jsonToTerm));
-  if (typeof v === "object") return makeStringLiteral(JSON.stringify(v));
-  return null;
-}
-
-function _jsonPointerLookup(jsonText, pointer) {
-  // Support URI fragment form "#/a/b" (percent-decoded) as well.
-  let ptr = pointer;
-  if (ptr.startsWith("#")) {
-    try { ptr = decodeURIComponent(ptr.slice(1)); } catch (e) { return null; }
-  }
-
-  // Cache per JSON document
-  let entry = jsonPointerCache.get(jsonText);
-  if (!entry) {
-    let parsed = null;
-    try { parsed = JSON.parse(jsonText); } catch (e) { parsed = null; }
-    entry = { parsed, ptrCache: new Map() };
-    jsonPointerCache.set(jsonText, entry);
-  }
-  if (entry.parsed === null) return null;
-
-  // Cache per pointer within this doc
-  if (entry.ptrCache.has(ptr)) return entry.ptrCache.get(ptr);
-
-  let cur = entry.parsed;
-
-  if (ptr === "") {
-    const t = _jsonToTerm(cur);
-    entry.ptrCache.set(ptr, t);
-    return t;
-  }
-  if (!ptr.startsWith("/")) { entry.ptrCache.set(ptr, null); return null; }
-
-  const parts = ptr.split("/").slice(1);
-  for (const raw of parts) {
-    const seg = _jsonPointerUnescape(raw);
-    if (seg === null) { entry.ptrCache.set(ptr, null); return null; }
-
-    if (Array.isArray(cur)) {
-      // JSON Pointer uses array indices as decimal strings
-      if (!/^(0|[1-9]\d*)$/.test(seg)) { entry.ptrCache.set(ptr, null); return null; }
-      const idx = Number(seg);
-      if (!Number.isFinite(idx) || idx < 0 || idx >= cur.length) { entry.ptrCache.set(ptr, null); return null; }
-      cur = cur[idx];
-      continue;
-    }
-
-    if (cur !== null && typeof cur === "object") {
-      if (!Object.prototype.hasOwnProperty.call(cur, seg)) { entry.ptrCache.set(ptr, null); return null; }
-      cur = cur[seg];
-      continue;
-    }
-
-    entry.ptrCache.set(ptr, null);
-    return null;
-  }
-
-  const out = _jsonToTerm(cur);
-  entry.ptrCache.set(ptr, out);
-  return out;
-}
-
 function jsonPointerUnescape(seg) {
   // RFC6901: ~1 -> '/', ~0 -> '~'
   let out = "";
@@ -1951,10 +1891,7 @@ function jsonToTerm(v) {
   if (Array.isArray(v)) return new ListTerm(v.map(jsonToTerm));
 
   if (v && typeof v === "object") {
-    // IMPORTANT: long literal so it can be parsed again via termToJsString()
-    // without needing escape decoding.
-    const raw = JSON.stringify(v);
-    return new Literal('"""' + raw + '"""');
+    return makeRdfJsonLiteral(JSON.stringify(v));
   }
   return null;
 }
@@ -3566,8 +3503,9 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
   // Schema: ( $jsonText $pointer ) string:jsonPointer $value
   if (g.p instanceof Iri && g.p.value === STRING_NS + "jsonPointer") {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
-    const jsonText = termToJsString(g.s.elems[0]);
-    const ptr = termToJsString(g.s.elems[1]);
+
+    const jsonText = termToJsonText(g.s.elems[0]);     // <-- changed
+    const ptr      = termToJsStringDecoded(g.s.elems[1]);
     if (jsonText === null || ptr === null) return [];
 
     const valTerm = jsonPointerLookup(jsonText, ptr);
@@ -3817,28 +3755,28 @@ function listHasTriple(list, tr) {
 //
 // This is semantics-preserving for the ongoing proof state.
 
-function _gcCollectVarsInTerm(t, out) {
+function gcCollectVarsInTerm(t, out) {
   if (t instanceof Var) { out.add(t.name); return; }
-  if (t instanceof ListTerm) { for (const e of t.elems) _gcCollectVarsInTerm(e, out); return; }
+  if (t instanceof ListTerm) { for (const e of t.elems) gcCollectVarsInTerm(e, out); return; }
   if (t instanceof OpenListTerm) {
-    for (const e of t.prefix) _gcCollectVarsInTerm(e, out);
+    for (const e of t.prefix) gcCollectVarsInTerm(e, out);
     out.add(t.tailVar);
     return;
   }
-  if (t instanceof FormulaTerm) { for (const tr of t.triples) _gcCollectVarsInTriple(tr, out); return; }
+  if (t instanceof FormulaTerm) { for (const tr of t.triples) gcCollectVarsInTriple(tr, out); return; }
 }
 
-function _gcCollectVarsInTriple(tr, out) {
-  _gcCollectVarsInTerm(tr.s, out);
-  _gcCollectVarsInTerm(tr.p, out);
-  _gcCollectVarsInTerm(tr.o, out);
+function gcCollectVarsInTriple(tr, out) {
+  gcCollectVarsInTerm(tr.s, out);
+  gcCollectVarsInTerm(tr.p, out);
+  gcCollectVarsInTerm(tr.o, out);
 }
 
-function _gcCollectVarsInGoals(goals, out) {
-  for (const g of goals) _gcCollectVarsInTriple(g, out);
+function gcCollectVarsInGoals(goals, out) {
+  for (const g of goals) gcCollectVarsInTriple(g, out);
 }
 
-function _substSizeOver(subst, limit) {
+function substSizeOver(subst, limit) {
   let c = 0;
   for (const _k in subst) {
     if (++c > limit) return true;
@@ -3846,9 +3784,9 @@ function _substSizeOver(subst, limit) {
   return false;
 }
 
-function _gcCompactForGoals(subst, goals, answerVars) {
+function gcCompactForGoals(subst, goals, answerVars) {
   const keep = new Set(answerVars);
-  _gcCollectVarsInGoals(goals, keep);
+  gcCollectVarsInGoals(goals, keep);
 
   const expanded = new Set();
   const queue = Array.from(keep);
@@ -3862,7 +3800,7 @@ function _gcCompactForGoals(subst, goals, answerVars) {
     if (bound === undefined) continue;
 
     const before = keep.size;
-    _gcCollectVarsInTerm(bound, keep);
+    gcCollectVarsInTerm(bound, keep);
     if (keep.size !== before) {
       for (const nv of keep) {
         if (!expanded.has(nv)) queue.push(nv);
@@ -3877,12 +3815,12 @@ function _gcCompactForGoals(subst, goals, answerVars) {
   return out;
 }
 
-function _maybeCompactSubst(subst, goals, answerVars, depth) {
+function maybeCompactSubst(subst, goals, answerVars, depth) {
   // Keep the fast path fast.
   // Only compact when the substitution is clearly getting large, or
   // we are in a deep chain (where the quadratic behavior shows up).
-  if (depth < 128 && !_substSizeOver(subst, 256)) return subst;
-  return _gcCompactForGoals(subst, goals, answerVars);
+  if (depth < 128 && !substSizeOver(subst, 256)) return subst;
+  return gcCompactForGoals(subst, goals, answerVars);
 }
 
 
@@ -3898,9 +3836,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
 
   // Variables from the original goal list (needed by the caller to instantiate conclusions)
   const answerVars = new Set();
-  _gcCollectVarsInGoals(initialGoals, answerVars);
+  gcCollectVarsInGoals(initialGoals, answerVars);
   if (!initialGoals.length) {
-    results.push(_gcCompactForGoals(initialSubst, [], answerVars));
+    results.push(gcCompactForGoals(initialSubst, [], answerVars));
     return results;
   }
 
@@ -3912,7 +3850,7 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
     const state = stack.pop();
 
     if (!state.goals.length) {
-      results.push(_gcCompactForGoals(state.subst, [], answerVars));
+      results.push(gcCompactForGoals(state.subst, [], answerVars));
       continue;
     }
 
@@ -3928,9 +3866,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         if (!restGoals.length) {
-          results.push(_gcCompactForGoals(composed, [], answerVars));
+          results.push(gcCompactForGoals(composed, [], answerVars));
         } else {
-          const nextSubst = _maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
+          const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           stack.push({
             goals: restGoals,
             subst: nextSubst,
@@ -3957,9 +3895,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         if (!restGoals.length) {
-          results.push(_gcCompactForGoals(composed, [], answerVars));
+          results.push(gcCompactForGoals(composed, [], answerVars));
         } else {
-          const nextSubst = _maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
+          const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           stack.push({
             goals: restGoals,
             subst: nextSubst,
@@ -3978,9 +3916,9 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         if (!restGoals.length) {
-          results.push(_gcCompactForGoals(composed, [], answerVars));
+          results.push(gcCompactForGoals(composed, [], answerVars));
         } else {
-          const nextSubst = _maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
+          const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           stack.push({
             goals: restGoals,
             subst: nextSubst,
@@ -4013,7 +3951,7 @@ function proveGoals( goals, subst, facts, backRules, depth, visited, varGen ) {
         if (composed === null) continue;
 
         const newGoals = body.concat(restGoals);
-        const nextSubst = _maybeCompactSubst(composed, newGoals, answerVars, state.depth + 1);
+        const nextSubst = maybeCompactSubst(composed, newGoals, answerVars, state.depth + 1);
         stack.push({
           goals: newGoals,
           subst: nextSubst,
@@ -4174,7 +4112,13 @@ function termToN3(t, pref) {
     if (i.startsWith("_:")) return i;
     return `<${i}>`;
   }
-  if (t instanceof Literal) return t.value;
+ if (t instanceof Literal) {
+   const [lex, dt] = literalParts(t.value);
+   if (!dt) return t.value; // keep numbers, booleans, lang-tagged strings, etc.
+   const qdt = pref.shrinkIri(dt);
+   if (qdt !== null) return `${lex}^^${qdt}`;   // e.g. ^^rdf:JSON
+   return `${lex}^^<${dt}>`;                   // fallback
+ }
   if (t instanceof Var) return `?${t.name}`;
   if (t instanceof Blank) return t.label;
   if (t instanceof ListTerm) {

package/package.json

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