eyeling 1.7.3 → 1.7.5

package/LICENSE.md

@@ -1,6 +1,6 @@
 # MIT License
 
-### Copyright 2021-2025 Jos De Roo, KNoWS office of IDLab, Ghent University - imec
+### Copyright 2021-2026 Jos De Roo, KNoWS office of IDLab, Ghent University - imec
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -215,7 +215,7 @@ Commonly used N3/Turtle features:
 
 - **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
 - **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:rest` `list:reverse` `list:sort`
-- **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
+- **log**: `log:collectAllIn` `log:content` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:semantics` `log:skolem` `log:uri`
 - **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:integerQuotient` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
 - **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:jsonPointer` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
 - **time**: `time:localTime`

package/examples/output/reaching-out.n3

@@ -0,0 +1,12 @@
+@prefix : <http://example.org/> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+:gotContent :is "# Schema for test data\n#\n# This is only \n@prefix daml: <http://www.daml.org/2001/03/daml+oil#> .\n@prefix mech: <#> .\n\n@prefix : <#> .\n\n:includes a daml:TransitiveProperty .\n\n:partOf a daml:TransitiveProperty; daml:inverseOf :includes .\n\n:dependsOn a daml:TransitiveProperty ;\n      daml:hasSubProperty  :includes .   # Real name of subproperty?\n\n\n\n\n"^^xsd:string .
+:gotFormula :is {
+    <https://www.w3.org/2000/10/swap/test/s1.n3#includes> a <http://www.daml.org/2001/03/daml+oil#TransitiveProperty> .
+    <https://www.w3.org/2000/10/swap/test/s1.n3#partOf> a <http://www.daml.org/2001/03/daml+oil#TransitiveProperty> .
+    <https://www.w3.org/2000/10/swap/test/s1.n3#partOf> <http://www.daml.org/2001/03/daml+oil#inverseOf> <https://www.w3.org/2000/10/swap/test/s1.n3#includes> .
+    <https://www.w3.org/2000/10/swap/test/s1.n3#dependsOn> a <http://www.daml.org/2001/03/daml+oil#TransitiveProperty> .
+    <https://www.w3.org/2000/10/swap/test/s1.n3#dependsOn> <http://www.daml.org/2001/03/daml+oil#hasSubProperty> <https://www.w3.org/2000/10/swap/test/s1.n3#includes> .
+} .

package/examples/reaching-out.n3

@@ -0,0 +1,19 @@
+# =============================================
+# Reaching out onto the Web
+# See https://www.w3.org/2000/10/swap/doc/Reach
+# =============================================
+
+@prefix : <http://example.org/>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+
+{
+  <https://www.w3.org/2000/10/swap/test/s1.n3>
+      log:content   ?txt ;
+      log:semantics ?f .
+}
+=>
+{
+  :gotContent :is ?txt .
+  :gotFormula :is ?f .
+}.
+

package/eyeling.js

@@ -82,6 +82,159 @@ const __parseNumericInfoCache = new Map(); // lit string -> info|null
 // Cache for string:jsonPointer: jsonText -> { parsed: any|null, ptrCache: Map<string, Term|null> }
 const jsonPointerCache = new Map();
 
+// -----------------------------------------------------------------------------
+// log:content / log:semantics support (basic, synchronous)
+// -----------------------------------------------------------------------------
+// Cache dereferenced resources within a single run.
+// Key is the dereferenced document IRI *without* fragment.
+const __logContentCache = new Map(); // iri -> string | null (null means fetch/read failed)
+const __logSemanticsCache = new Map(); // iri -> GraphTerm | null (null means parse failed)
+
+function __stripFragment(iri) {
+  const i = iri.indexOf('#');
+  return i >= 0 ? iri.slice(0, i) : iri;
+}
+
+function __isHttpIri(iri) {
+  return typeof iri === 'string' && (iri.startsWith('http://') || iri.startsWith('https://'));
+}
+
+function __isFileIri(iri) {
+  return typeof iri === 'string' && iri.startsWith('file://');
+}
+
+function __fileIriToPath(fileIri) {
+  // Basic file:// URI decoding. Handles file:///abs/path and file://localhost/abs/path.
+  try {
+    const u = new URL(fileIri);
+    return decodeURIComponent(u.pathname);
+  } catch {
+    return decodeURIComponent(fileIri.replace(/^file:\/\//, ''));
+  }
+}
+
+function __readFileText(pathOrFileIri) {
+  const fs = require('fs');
+  let path = pathOrFileIri;
+  if (__isFileIri(pathOrFileIri)) path = __fileIriToPath(pathOrFileIri);
+  try {
+    return fs.readFileSync(path, { encoding: 'utf8' });
+  } catch {
+    return null;
+  }
+}
+
+function __fetchHttpTextViaSubprocess(url) {
+  const cp = require('child_process');
+  // Use a subprocess so this code remains synchronous without rewriting the whole reasoner to async.
+  const script = `
+    const url = process.argv[1];
+    const maxRedirects = 10;
+    function get(u, n) {
+      if (n > maxRedirects) { console.error('Too many redirects'); process.exit(3); }
+      let mod;
+      if (u.startsWith('https://')) mod = require('https');
+      else if (u.startsWith('http://')) mod = require('http');
+      else { console.error('Not http(s)'); process.exit(2); }
+
+      const { URL } = require('url');
+      const uu = new URL(u);
+      const opts = {
+        protocol: uu.protocol,
+        hostname: uu.hostname,
+        port: uu.port || undefined,
+        path: uu.pathname + uu.search,
+        headers: {
+          'accept': 'text/n3, text/turtle, application/n-triples, application/n-quads, text/plain;q=0.1, */*;q=0.01',
+          'user-agent': 'eyeling-log-builtins'
+        }
+      };
+      const req = mod.request(opts, (res) => {
+        const sc = res.statusCode || 0;
+        if (sc >= 300 && sc < 400 && res.headers && res.headers.location) {
+          const next = new URL(res.headers.location, u).toString();
+          res.resume();
+          return get(next, n + 1);
+        }
+        if (sc < 200 || sc >= 300) {
+          res.resume();
+          console.error('HTTP status ' + sc);
+          process.exit(4);
+        }
+        res.setEncoding('utf8');
+        let data = '';
+        res.on('data', (c) => { data += c; });
+        res.on('end', () => { process.stdout.write(data); });
+      });
+      req.on('error', (e) => { console.error(e && e.message ? e.message : String(e)); process.exit(5); });
+      req.end();
+    }
+    get(url, 0);
+  `;
+  const r = cp.spawnSync(process.execPath, ['-e', script, url], {
+    encoding: 'utf8',
+    maxBuffer: 32 * 1024 * 1024
+  });
+  if (r.status !== 0) return null;
+  return r.stdout;
+}
+
+function __derefTextSync(iriNoFrag) {
+  if (__logContentCache.has(iriNoFrag)) return __logContentCache.get(iriNoFrag);
+
+  let text = null;
+  if (__isHttpIri(iriNoFrag)) {
+    text = __fetchHttpTextViaSubprocess(iriNoFrag);
+  } else {
+    // Treat any non-http(s) IRI as a local path (including file://), for basic usability.
+    text = __readFileText(iriNoFrag);
+  }
+  __logContentCache.set(iriNoFrag, text);
+  return text;
+}
+
+function __parseSemanticsToFormula(text, baseIri) {
+  const toks = lex(text);
+  const parser = new Parser(toks);
+  if (typeof baseIri === 'string' && baseIri) parser.prefixes.setBase(baseIri);
+
+  const [_prefixes, triples, frules, brules] = parser.parseDocument();
+
+  const all = triples.slice();
+  const impliesPred = internIri(LOG_NS + 'implies');
+  const impliedByPred = internIri(LOG_NS + 'impliedBy');
+
+  // Represent top-level => / <= rules as triples between formula terms,
+  // so the returned formula can include them.
+  for (const r of frules) {
+    all.push(new Triple(new GraphTerm(r.premise), impliesPred, new GraphTerm(r.conclusion)));
+  }
+  for (const r of brules) {
+    all.push(new Triple(new GraphTerm(r.conclusion), impliedByPred, new GraphTerm(r.premise)));
+  }
+
+  return new GraphTerm(all);
+}
+
+function __derefSemanticsSync(iriNoFrag) {
+  if (__logSemanticsCache.has(iriNoFrag)) return __logSemanticsCache.get(iriNoFrag);
+
+  const text = __derefTextSync(iriNoFrag);
+  if (typeof text !== 'string') {
+    __logSemanticsCache.set(iriNoFrag, null);
+    return null;
+  }
+  try {
+    const formula = __parseSemanticsToFormula(text, iriNoFrag);
+    __logSemanticsCache.set(iriNoFrag, formula);
+    return formula;
+  } catch {
+    __logSemanticsCache.set(iriNoFrag, null);
+    return null;
+  }
+}
+
+
 // Controls whether human-readable proof comments are printed.
 let proofCommentsEnabled = false;
 // Super restricted mode: disable *all* builtins except => / <= (log:implies / log:impliedBy)
@@ -4569,19 +4722,26 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     const inputList = inputTerm.elems;
     if (!(predTerm instanceof Iri)) return [];
     const pred = internIri(predTerm.value);
-    if (!isBuiltinPred(pred)) return [];
+
+    // Allow mapping *any* predicate (not just builtins).
+    // Semantics: for each input element `el`, collect *all* solutions of `el pred ?y`
+    // (facts, rules, and builtins), in order, and concatenate them into the output list.
+    // If an element has no solutions, it contributes nothing.
     if (!inputList.every((e) => isGroundTerm(e))) return [];
 
     const results = [];
     for (const el of inputList) {
       const yvar = new Var('_mapY');
       const goal2 = new Triple(el, pred, yvar);
-      const sols = evalBuiltin(goal2, subst, facts, backRules, depth + 1, varGen);
-      if (!sols.length) return [];
-      const yval = applySubstTerm(yvar, sols[0]);
-      if (yval instanceof Var) return [];
-      results.push(yval);
+      const sols = proveGoals([goal2], subst, facts, backRules, depth + 1, [], varGen);
+
+      for (const sol of sols) {
+        const yval = applySubstTerm(yvar, sol);
+        if (yval instanceof Var) continue;
+        results.push(yval);
+      }
     }
+
     const outList = new ListTerm(results);
     const s2 = unifyTerm(g.o, outList, subst);
     return s2 !== null ? [s2] : [];
@@ -4690,6 +4850,53 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return s2 !== null ? [s2] : [];
   }
 
+  // log:content
+  // Schema: $s+ log:content $o?
+  // Dereferences $s and returns the online resource as an xsd:string.
+  if (pv === LOG_NS + 'content') {
+    const iri = iriValue(g.s);
+    if (iri === null) return [];
+    const docIri = __stripFragment(iri);
+
+    const text = __derefTextSync(docIri);
+    if (typeof text !== 'string') return [];
+
+    const lit = internLiteral(`${JSON.stringify(text)}^^<${XSD_NS}string>`);
+
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // log:semantics
+  // Schema: $s+ log:semantics $o?
+  // Dereferences $s, parses the retrieved resource, and returns it as a formula.
+  if (pv === LOG_NS + 'semantics') {
+    const iri = iriValue(g.s);
+    if (iri === null) return [];
+    const docIri = __stripFragment(iri);
+
+    const formula = __derefSemanticsSync(docIri);
+    if (!(formula instanceof GraphTerm)) return [];
+
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = formula;
+      return [s2];
+    }
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const s2 = unifyTerm(g.o, formula, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+
   // log:dtlit
   // Schema: ( $s.1? $s.2? )? log:dtlit $o?
   // true iff $o is a datatyped literal with string value $s.1 and datatype IRI $s.2

package/package.json

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