eyeling 1.25.5 → 1.26.0

package/lib/multisource.js

@@ -31,6 +31,67 @@ function emptyParsedDocument() {
   };
 }
 
+function lineStartsForText(text) {
+  const s = String(text);
+  const starts = [0];
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 10) starts.push(i + 1); // LF
+    else if (c === 13) { // CR or CRLF
+      if (i + 1 < s.length && s.charCodeAt(i + 1) === 10) i++;
+      starts.push(i + 1);
+    }
+  }
+  return starts;
+}
+
+function offsetToLineFromStarts(offset, lineStarts) {
+  if (typeof offset !== 'number') return null;
+  let lo = 0;
+  let hi = lineStarts.length;
+  while (lo + 1 < hi) {
+    const mid = (lo + hi) >> 1;
+    if (lineStarts[mid] <= offset) lo = mid;
+    else hi = mid;
+  }
+  return lo + 1;
+}
+
+function annotateSourceLocation(obj, label, lineStarts) {
+  if (!obj || typeof obj.__sourceOffset !== 'number') return obj;
+  const line = offsetToLineFromStarts(obj.__sourceOffset, lineStarts);
+  Object.defineProperty(obj, '__source', {
+    value: { label, line },
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return obj;
+}
+
+function annotateParsedSourceLocations(doc, text, label) {
+  const lineStarts = lineStartsForText(text);
+  for (const tr of doc.triples || []) annotateSourceLocation(tr, label, lineStarts);
+  for (const r of doc.frules || []) annotateSourceLocation(r, label, lineStarts);
+  for (const r of doc.brules || []) annotateSourceLocation(r, label, lineStarts);
+  for (const r of doc.logQueryRules || []) annotateSourceLocation(r, label, lineStarts);
+}
+
+function copySourceMetadata(from, to) {
+  if (!from || !to) return to;
+  for (const key of ['__sourceOffset', '__source']) {
+    if (Object.prototype.hasOwnProperty.call(from, key)) {
+      Object.defineProperty(to, key, {
+        value: from[key],
+        enumerable: false,
+        writable: false,
+        configurable: true,
+      });
+    }
+  }
+  return to;
+}
+
 function prefixesUsedInTokens(tokens, prefEnv) {
   const used = new Set();
   const toks = Array.isArray(tokens) ? tokens : [];
@@ -108,6 +169,7 @@ function parseN3Text(text, opts = {}) {
     label = '<input>',
     keepSourceArtifacts = true,
     collectUsedPrefixes = false,
+    collectSourceLocations = true,
     rdf = false,
   } = opts || {};
   const tokens = lex(text, { rdf });
@@ -116,6 +178,7 @@ function parseN3Text(text, opts = {}) {
   const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
 
   const doc = { prefixes, triples, frules, brules, logQueryRules, label };
+  if (collectSourceLocations) annotateParsedSourceLocations(doc, text, label);
 
   if (collectUsedPrefixes) {
     Object.defineProperty(doc, 'usedPrefixes', {
@@ -161,7 +224,7 @@ function scopeBlankNodesInDocument(doc, sourceIndex) {
   }
 
   function cloneTriple(triple) {
-    return new Triple(cloneTerm(triple.s), cloneTerm(triple.p), cloneTerm(triple.o));
+    return copySourceMetadata(triple, new Triple(cloneTerm(triple.s), cloneTerm(triple.p), cloneTerm(triple.o)));
   }
 
   function cloneRule(rule) {
@@ -170,12 +233,15 @@ function scopeBlankNodesInDocument(doc, sourceIndex) {
       for (const label of rule.headBlankLabels) headBlankLabels.add(scopedBlankLabel(label, sourceIndex, mapping));
     }
 
-    const out = new Rule(
-      (rule.premise || []).map(cloneTriple),
-      (rule.conclusion || []).map(cloneTriple),
-      rule.isForward,
-      rule.isFuse,
-      headBlankLabels,
+    const out = copySourceMetadata(
+      rule,
+      new Rule(
+        (rule.premise || []).map(cloneTriple),
+        (rule.conclusion || []).map(cloneTriple),
+        rule.isForward,
+        rule.isFuse,
+        headBlankLabels,
+      ),
     );
 
     if (rule && Object.prototype.hasOwnProperty.call(rule, '__dynamicConclusionTerm')) {
@@ -303,6 +369,7 @@ function parseN3SourceList(input, opts = {}) {
       label: source.label,
       baseIri: source.baseIri || (sources.length === 1 ? defaultBaseIri : ''),
       collectUsedPrefixes: true,
+      collectSourceLocations: !!opts.collectSourceLocations,
       keepSourceArtifacts: !!opts.keepSourceArtifacts,
       rdf: !!opts.rdf,
     }),

package/lib/parser.js

@@ -42,6 +42,17 @@ function failInvalidKeywordLikeIdent(fail, tok, name) {
   fail(`invalid_keyword(${name})`, tok);
 }
 
+function annotateSourceOffset(obj, offset) {
+  if (!obj || typeof offset !== 'number') return obj;
+  Object.defineProperty(obj, '__sourceOffset', {
+    value: offset,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return obj;
+}
+
 class Parser {
   constructor(tokens) {
     this.toks = tokens;
@@ -166,17 +177,19 @@ class Parser {
         continue;
       }
 
+      const statementToken = this.peek();
+      const statementOffset = statementToken && typeof statementToken.offset === 'number' ? statementToken.offset : null;
       const first = this.parseTerm();
       if (this.peek().typ === 'OpImplies') {
         this.next();
         const second = this.parseTerm();
         this.expectDot();
-        forwardRules.push(this.makeRule(first, second, true));
+        forwardRules.push(annotateSourceOffset(this.makeRule(first, second, true), statementOffset));
       } else if (this.peek().typ === 'OpImpliedBy') {
         this.next();
         const second = this.parseTerm();
         this.expectDot();
-        backwardRules.push(this.makeRule(first, second, false));
+        backwardRules.push(annotateSourceOffset(this.makeRule(first, second, false), statementOffset));
       } else {
         let more;
 
@@ -194,16 +207,17 @@ class Parser {
         }
 
         // normalize explicit log:implies / log:impliedBy at top-level
-        for (const tr of more) {
+        for (const tr0 of more) {
+          const tr = annotateSourceOffset(tr0, statementOffset);
           if (isLogImplies(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
-            forwardRules.push(this.makeRule(tr.s, tr.o, true));
+            forwardRules.push(annotateSourceOffset(this.makeRule(tr.s, tr.o, true), statementOffset));
           } else if (isLogImpliedBy(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
-            backwardRules.push(this.makeRule(tr.s, tr.o, false));
+            backwardRules.push(annotateSourceOffset(this.makeRule(tr.s, tr.o, false), statementOffset));
           } else if (isLogQuery(tr.p) && tr.s instanceof GraphTerm && tr.o instanceof GraphTerm) {
             // Output-selection directive: { premise } log:query { conclusion }.
             // When present at top-level, eyeling prints only the instantiated conclusion
             // triples (unique) instead of all newly derived facts.
-            logQueries.push(this.makeRule(tr.s, tr.o, true));
+            logQueries.push(annotateSourceOffset(this.makeRule(tr.s, tr.o, true), statementOffset));
           } else {
             triples.push(tr);
           }

package/package.json

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

package/test/api.test.js

@@ -454,7 +454,7 @@ ${U('x')} ${U('age')} "42".
 ${U('s')} ${U('p')} ${U('o')}.
 `,
     expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
-    notExpect: [/^#/m],
+    notExpect: [/pe:why/m],
   },
   {
     name: '11 negative entailment: rule derives false (expect exit 65 => throws)',
@@ -1038,23 +1038,23 @@ ${U('a')} ${U('p')} ${U('b')}.
     expect: [new RegExp(`${EX}a>\\s+<${EX}q2>\\s+<${EX}b>\\s*\\.`)],
   },
   {
-    name: '30 sanity: proofComments:true enables proof comments',
-    opt: { proofComments: true },
+    name: '30 sanity: proof:true enables N3 proof explanations',
+    opt: { proof: true },
     input: `
 { ${U('s')} ${U('p')} ${U('o')}. } => { ${U('s')} ${U('q')} ${U('o')}. }.
 ${U('s')} ${U('p')} ${U('o')}.
 `,
-    expect: [/^#/m, new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
+    expect: [/pe:why/m, /pe:by/m, new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
   },
   {
-    name: '31 sanity: -n suppresses proof comments',
+    name: '31 sanity: default output has no proof explanations',
     opt: ['-n'],
     input: `
 { ${U('s')} ${U('p')} ${U('o')}. } => { ${U('s')} ${U('q')} ${U('o')}. }.
 ${U('s')} ${U('p')} ${U('o')}.
 `,
     expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+<${EX}o>\\s*\\.`)],
-    notExpect: [/^#/m],
+    notExpect: [/pe:why/m],
   },
 
   // -------------------------

package/tools/bundle.js

@@ -158,6 +158,9 @@ function buildBundleSource({ autoRunMain }) {
   out.push(
     '      if (typeof __entry.printExplanation === "function") __outerSelf.printExplanation = __entry.printExplanation;',
   );
+  out.push(
+    '      if (typeof __entry.renderProofDocument === "function") __outerSelf.renderProofDocument = __entry.renderProofDocument;',
+  );
   out.push('      if (typeof __entry.tripleToN3 === "function") __outerSelf.tripleToN3 = __entry.tripleToN3;');
   out.push(
     '      if (typeof __entry.collectOutputStringsFromFacts === "function") __outerSelf.collectOutputStringsFromFacts = __entry.collectOutputStringsFromFacts;',