eyeling 1.26.0 → 1.26.1

package/lib/explain.js

@@ -135,7 +135,6 @@ ${lineIndent(body, '    ')}
 }`;
   }
 
-
   function clonePrefixEnvWithProofVocabulary(prefixes) {
     const map = { ...(prefixes && prefixes.map ? prefixes.map : {}) };
     if (!map.pe) map.pe = PE_NS;
@@ -153,6 +152,11 @@ ${lineIndent(body, '    ')}
     return source.label.replace(/\\/g, '/').split('/').pop() || source.label;
   }
 
+  function sourceKeyForProof(source) {
+    if (!source) return '<unknown>';
+    return `${sourceLabelForProof(source)}:${Number.isInteger(source.line) ? source.line : ''}`;
+  }
+
   function byBlankNode(kind, source) {
     const src = source || {};
     const props = [`pe:${kind} ${n3String(sourceLabelForProof(src))}`];
@@ -160,121 +164,129 @@ ${lineIndent(body, '    ')}
     return `[ ${props.join('; ')} ]`;
   }
 
-  function renderBindingList(df, prefixes) {
-    if (!df || !df.rule || !df.subst) return '';
+  function renderBindingItems(df, prefixes) {
+    if (!df || !df.rule || !df.subst) return [];
     const ruleVars = varsInRule(df.rule);
     const visibleNames = Object.keys(df.subst)
       .filter((name) => ruleVars.has(name))
       .sort();
-    if (!visibleNames.length) return '';
+    if (!visibleNames.length) return [];
     const sourceNames = (df.rule && df.rule.__proofVarSourceNames) || null;
-    return visibleNames
-      .map((name) => {
-        const value = applySubstTerm(new Var(name), df.subst);
-        const displayName = sourceNames && sourceNames[name] ? sourceNames[name] : name;
-        return `[ pe:var ${n3String(displayName)}; pe:value ${termToN3(value, prefixes)} ]`;
-      })
-      .join(', ');
+    return visibleNames.map((name) => {
+      const value = applySubstTerm(new Var(name), df.subst);
+      const displayName = sourceNames && sourceNames[name] ? sourceNames[name] : name;
+      return `[ pe:var ${n3String(displayName)}; pe:value ${termToN3(value, prefixes)} ]`;
+    });
   }
 
-  function proofSourceKey(source) {
-    if (!source) return '';
-    const label = typeof source.label === 'string' ? source.label : '';
-    const line = Number.isInteger(source.line) ? source.line : 0;
-    return `${label}\t${line}`;
+  function withLastLineSuffix(text, suffix) {
+    const lines = String(text).split(/\r?\n/);
+    lines[lines.length - 1] += suffix;
+    return lines.join('\n');
   }
 
-  function proofEntryKey(kind, fact, source, extra) {
-    return `${kind}\t${proofTripleKey(fact)}\t${proofSourceKey(source)}\t${extra || ''}`;
+  function renderPredicateObjects(predicate, objects, isLast) {
+    const values = (objects || []).filter((value) => value);
+    if (!values.length) return [];
+    const end = isLast ? '.' : ';';
+    if (values.length === 1 && !values[0].includes('\n')) {
+      return [`    ${predicate} ${values[0]}${end}`];
+    }
+    const out = [`    ${predicate}`];
+    for (let i = 0; i < values.length; i++) {
+      const suffix = i === values.length - 1 ? end : ',';
+      out.push(lineIndent(withLastLineSuffix(values[i], suffix), '      '));
+    }
+    return out;
   }
 
-  function ruleEntryKey(df) {
-    const rule = df && df.rule;
-    const premises = (df && df.premises ? df.premises : []).map((prem) => proofTripleKey(prem)).join('\t');
-    return proofEntryKey('rule', df && df.fact, rule && rule.__source, premises);
+  function proofEntryKey(entry) {
+    if (!entry) return '';
+    if (entry.kind === 'rule') {
+      const df = entry.df;
+      const source = df && df.rule && df.rule.__source;
+      const premiseKey = (df && df.premises ? df.premises : []).map(proofTripleKey).join('|');
+      return `rule:${proofTripleKey(df && df.fact)}:${sourceKeyForProof(source)}:${premiseKey}`;
+    }
+    if (entry.kind === 'builtin') return `builtin:${proofTripleKey(entry.fact)}`;
+    return `fact:${proofTripleKey(entry.fact)}:${sourceKeyForProof(entry.source)}`;
   }
 
   function collectProofEntries(rootDf, derivedByKey, baseFactByKey, resolveBackwardProof) {
     const entries = [];
     const seen = new Set();
 
-    function entryKeyForProof(proof, fallbackTriple) {
-      if (!proof) return proofEntryKey('fact', fallbackTriple, null);
-      if (proof.kind === 'rule') return ruleEntryKey(proof.df);
-      if (proof.kind === 'builtin') return proofEntryKey('builtin', proof.fact || fallbackTriple, null);
-      return proofEntryKey('fact', proof.fact || fallbackTriple, proof.source);
+    function remember(entry) {
+      const key = proofEntryKey(entry);
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      entries.push(entry);
+      return true;
+    }
+
+    function derivedCandidatesForKey(key) {
+      const found = derivedByKey.get(key);
+      if (!found) return [];
+      return Array.isArray(found) ? found : [found];
     }
 
-    function visitProofNode(proof, fallbackTriple) {
+    function visitProofNode(proof, fallbackTriple, parentDf) {
       if (!proof) {
-        visitFactTriple(fallbackTriple);
+        visitFactTriple(fallbackTriple, parentDf);
         return;
       }
-      const key = entryKeyForProof(proof, fallbackTriple);
-      if (!key || seen.has(key)) return;
       if (proof.kind === 'rule' && proof.df) {
         visitDerivedFact(proof.df, proof.children || null);
         return;
       }
-      seen.add(key);
       if (proof.kind === 'builtin') {
-        entries.push({
-          kind: 'builtin',
-          fact: proof.fact || fallbackTriple,
-          builtin: proof.builtin || (proof.fact && proof.fact.p),
-        });
-      } else {
-        entries.push({ kind: 'fact', fact: proof.fact || fallbackTriple, source: proof.source });
+        remember({ kind: 'builtin', fact: proof.fact || fallbackTriple, builtin: proof.builtin || (proof.fact && proof.fact.p) });
+        return;
       }
+      remember({ kind: 'fact', fact: proof.fact || fallbackTriple, source: proof.source });
     }
 
-    function visitFactTriple(tr) {
-      const tripleKey = proofTripleKey(tr);
-      if (!tripleKey) return;
-      const df = derivedByKey.get(tripleKey);
-      if (df) {
-        visitDerivedFact(df);
+    function visitFactTriple(tr, parentDf) {
+      const key = proofTripleKey(tr);
+      const base = baseFactByKey.get(key) || null;
+      if (base) {
+        remember({ kind: 'fact', fact: base, source: base.__source });
         return;
       }
-      const base = baseFactByKey.get(tripleKey) || null;
-      if (base) {
-        const key = proofEntryKey('fact', base, base.__source);
-        if (seen.has(key)) return;
-        seen.add(key);
-        entries.push({ kind: 'fact', fact: base, source: base.__source });
+
+      const candidates = derivedCandidatesForKey(key);
+      const df = candidates.find((candidate) => candidate !== parentDf) || null;
+      if (df) {
+        visitDerivedFact(df);
         return;
       }
+
       if (tr && isBuiltinPred(tr.p)) {
-        const key = proofEntryKey('builtin', tr, null);
-        if (seen.has(key)) return;
-        seen.add(key);
-        entries.push({ kind: 'builtin', fact: tr, builtin: tr.p });
+        remember({ kind: 'builtin', fact: tr, builtin: tr.p });
         return;
       }
+
       if (resolveBackwardProof) {
         const proof = resolveBackwardProof(tr);
         if (proof) {
-          visitProofNode(proof, tr);
+          visitProofNode(proof, tr, parentDf);
           return;
         }
       }
-      const key = proofEntryKey('fact', tr, null);
-      if (seen.has(key)) return;
-      seen.add(key);
-      entries.push({ kind: 'fact', fact: tr, source: null });
+
+      remember({ kind: 'fact', fact: tr, source: null });
     }
 
     function visitDerivedFact(df, children) {
-      const key = ruleEntryKey(df);
-      if (!key || seen.has(key)) return;
-      seen.add(key);
-      entries.push({ kind: 'rule', df });
+      if (!df || !df.fact) return;
+      const entry = { kind: 'rule', df };
+      if (!remember(entry)) return;
 
       if (Array.isArray(children) && children.length) {
-        for (const child of children) visitProofNode(child);
+        for (const child of children) visitProofNode(child, null, df);
         return;
       }
-      for (const prem of df.premises || []) visitFactTriple(prem);
+      for (const prem of df.premises || []) visitFactTriple(prem, df);
     }
 
     visitDerivedFact(rootDf);
@@ -304,16 +316,18 @@ ${lineIndent(body, '    ')}
     }
 
     const df = entry.df;
-    const props = [`pe:by ${byBlankNode('rule', df.rule && df.rule.__source)}`];
-    const bindings = renderBindingList(df, prefixes);
-    if (bindings) props.push(`pe:binding ${bindings}`);
-    if (df.premises && df.premises.length) {
-      props.push(`pe:uses ${df.premises.map((prem) => graphForTriple(prem, prefixes)).join(', ')}`);
-    }
+    const bindingItems = renderBindingItems(df, prefixes);
+    const useItems = (df.premises || []).map((prem) => graphForTriple(prem, prefixes));
+    const propertyGroups = [
+      { predicate: 'pe:by', objects: [byBlankNode('rule', df.rule && df.rule.__source)] },
+      { predicate: 'pe:binding', objects: bindingItems },
+      { predicate: 'pe:uses', objects: useItems },
+    ].filter((group) => group.objects.length);
 
     let out = `  ${graphForTriple(df.fact, prefixes)}\n`;
-    for (let i = 0; i < props.length; i++) {
-      out += `    ${props[i]}${i === props.length - 1 ? '.' : ';'}\n`;
+    for (let i = 0; i < propertyGroups.length; i++) {
+      const group = propertyGroups[i];
+      out += renderPredicateObjects(group.predicate, group.objects, i === propertyGroups.length - 1).join('\n') + '\n';
     }
     return out.trimEnd();
   }
@@ -334,13 +348,18 @@ ${proofBody}
 
     const proofPrefixes = clonePrefixEnvWithProofVocabulary(prefixes);
     const derivedByKey = new Map();
-    for (const df of allDerived || []) {
-      if (!df || !df.fact) continue;
+    function addDerived(df) {
+      if (!df || !df.fact) return;
       const key = proofTripleKey(df.fact);
-      if (!derivedByKey.has(key)) derivedByKey.set(key, df);
+      let bucket = derivedByKey.get(key);
+      if (!bucket) {
+        bucket = [];
+        derivedByKey.set(key, bucket);
+      }
+      if (!bucket.includes(df)) bucket.push(df);
     }
-    // Do not insert query-wrapper output facts here: those wrappers often derive
-    // the same triple they use, and would hide the underlying fact/rule proof.
+    for (const df of allDerived || []) addDerived(df);
+    for (const df of selectedDerived) addDerived(df);
 
     const baseFactByKey = new Map();
     for (const tr of baseFacts || []) {

package/lib/multisource.js

@@ -32,20 +32,20 @@ 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);
+  const str = String(text);
+  for (let i = 0; i < str.length; i++) {
+    const c = str[i];
+    if (c === '\n') starts.push(i + 1);
+    else if (c === '\r') {
+      starts.push(i + 1 < str.length && str[i + 1] === '\n' ? i + 2 : i + 1);
+      if (i + 1 < str.length && str[i + 1] === '\n') i++;
     }
   }
   return starts;
 }
 
-function offsetToLineFromStarts(offset, lineStarts) {
+function offsetToLine(lineStarts, offset) {
   if (typeof offset !== 'number') return null;
   let lo = 0;
   let hi = lineStarts.length;
@@ -57,9 +57,9 @@ function offsetToLineFromStarts(offset, lineStarts) {
   return lo + 1;
 }
 
-function annotateSourceLocation(obj, label, lineStarts) {
+function annotateSourceLocation(obj, lineStarts, label) {
   if (!obj || typeof obj.__sourceOffset !== 'number') return obj;
-  const line = offsetToLineFromStarts(obj.__sourceOffset, lineStarts);
+  const line = offsetToLine(lineStarts, obj.__sourceOffset);
   Object.defineProperty(obj, '__source', {
     value: { label, line },
     enumerable: false,
@@ -71,10 +71,10 @@ function annotateSourceLocation(obj, label, lineStarts) {
 
 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);
+  for (const tr of doc.triples || []) annotateSourceLocation(tr, lineStarts, label);
+  for (const r of doc.frules || []) annotateSourceLocation(r, lineStarts, label);
+  for (const r of doc.brules || []) annotateSourceLocation(r, lineStarts, label);
+  for (const r of doc.logQueryRules || []) annotateSourceLocation(r, lineStarts, label);
 }
 
 function copySourceMetadata(from, to) {
@@ -169,7 +169,7 @@ function parseN3Text(text, opts = {}) {
     label = '<input>',
     keepSourceArtifacts = true,
     collectUsedPrefixes = false,
-    collectSourceLocations = true,
+    sourceLocations = false,
     rdf = false,
   } = opts || {};
   const tokens = lex(text, { rdf });
@@ -178,7 +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 (sourceLocations) annotateParsedSourceLocations(doc, text, label);
 
   if (collectUsedPrefixes) {
     Object.defineProperty(doc, 'usedPrefixes', {
@@ -369,8 +369,8 @@ function parseN3SourceList(input, opts = {}) {
       label: source.label,
       baseIri: source.baseIri || (sources.length === 1 ? defaultBaseIri : ''),
       collectUsedPrefixes: true,
-      collectSourceLocations: !!opts.collectSourceLocations,
       keepSourceArtifacts: !!opts.keepSourceArtifacts,
+      sourceLocations: !!opts.sourceLocations,
       rdf: !!opts.rdf,
     }),
   );

package/package.json

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