eyeling 1.5.31 → 1.5.33

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,11 +34,36 @@ 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.
 const skolemCache = new Map();
 
+// Cache for string:jsonPointer: jsonText -> { parsed: any|null, ptrCache: Map<string, Term|null> }
+const jsonPointerCache = new Map();
+
 // Controls whether human-readable proof comments are printed.
 let proofCommentsEnabled = true;
 
@@ -549,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) {
@@ -1819,6 +1847,192 @@ function makeStringLiteral(str) {
   return new Literal(JSON.stringify(str));
 }
 
+function termToJsStringDecoded(t) {
+  // Like termToJsString, but for short literals it *also* interprets escapes
+  // (\" \n \uXXXX …) by attempting JSON.parse on the quoted lexical form.
+  if (!(t instanceof Literal)) return null;
+  const [lex, _dt] = literalParts(t.value);
+
+  // Long strings: """ ... """ are taken verbatim.
+  if (lex.length >= 6 && lex.startsWith('"""') && lex.endsWith('"""')) {
+    return lex.slice(3, -3);
+  }
+
+  // Short strings: try to decode escapes (this makes "{\"a\":1}" usable too).
+  if (lex.length >= 2 && lex[0] === '"' && lex[lex.length - 1] === '"') {
+    try { return JSON.parse(lex); } catch (e) { /* fall through */ }
+    return stripQuotes(lex);
+  }
+
+  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 = "";
+  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 (v && typeof v === "object") {
+    return makeRdfJsonLiteral(JSON.stringify(v));
+  }
+  return null;
+}
+
+function jsonPointerLookup(jsonText, pointer) {
+  let ptr = pointer;
+
+  // Support URI fragment form "#/a/b"
+  if (ptr.startsWith("#")) {
+    try { ptr = decodeURIComponent(ptr.slice(1)); } catch { return null; }
+  }
+
+  let entry = jsonPointerCache.get(jsonText);
+  if (!entry) {
+    let parsed = null;
+    try { parsed = JSON.parse(jsonText); } catch { parsed = null; }
+    entry = { parsed, ptrCache: new Map() };
+    jsonPointerCache.set(jsonText, entry);
+  }
+  if (entry.parsed === null) return null;
+
+  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)) {
+      if (!/^(0|[1-9]\d*)$/.test(seg)) { entry.ptrCache.set(ptr, null); return null; }
+      const idx = Number(seg);
+      if (idx < 0 || idx >= cur.length) { entry.ptrCache.set(ptr, null); return null; }
+      cur = cur[idx];
+    } else if (cur !== null && typeof cur === "object") {
+      if (!Object.prototype.hasOwnProperty.call(cur, seg)) { entry.ptrCache.set(ptr, null); return null; }
+      cur = cur[seg];
+    } else {
+      entry.ptrCache.set(ptr, null);
+      return null;
+    }
+  }
+
+  const out = jsonToTerm(cur);
+  entry.ptrCache.set(ptr, out);
+  return out;
+}
+
 // Tiny subset of sprintf: supports only %s and %%.
 // Good enough for most N3 string:format use cases that just splice strings.
 function simpleStringFormat(fmt, args) {
@@ -3370,6 +3584,22 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return s2 !== null ? [s2] : [];
   }
 
+  // string:jsonPointer
+  // 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 = termToJsonText(g.s.elems[0]);     // <-- changed
+    const ptr      = termToJsStringDecoded(g.s.elems[1]);
+    if (jsonText === null || ptr === null) return [];
+
+    const valTerm = jsonPointerLookup(jsonText, ptr);
+    if (valTerm === null) return [];
+
+    const s2 = unifyTerm(g.o, valTerm, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
   // string:greaterThan
   if (g.p instanceof Iri && g.p.value === STRING_NS + "greaterThan") {
     const sStr = termToJsString(g.s);
@@ -3967,7 +4197,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.31",
+  "version": "1.5.33",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [