n3 2.2.8 → 2.2.10

package/lib/N3Reasoner.js

@@ -33,7 +33,7 @@ class N3Reasoner {
     // Caps a rule's premise count, as `_evaluatePremise` recurses once per premise
     this._maxPremiseDepth = options.maxPremiseDepth === undefined ? Infinity : options.maxPremiseDepth;
   }
-  _add(subject, predicate, object, graphItem, cb) {
+  _add(subject, predicate, object, graphItem, c, cb) {
     // Only add to the remaining indexes if there is not already a value in the index
     if (!this._store._addToIndex(graphItem.subjects, subject, predicate, object)) return;
     this._store._addToIndex(graphItem.predicates, predicate, object, subject);
@@ -42,43 +42,63 @@ class N3Reasoner {
     // after all three indexes are updated, so a caught error leaves the store
     // in a consistent state (the reasoning result is merely incomplete).
     if (++this._derivations > this._maxDerivations) throw new Error(`Reasoning exceeded the maximum of ${this._maxDerivations} derivations`);
-    cb();
+    cb(c);
   }
+
+  // Emit conclusions without allocating per-match callbacks
+  _emit(rule, content, cb) {
+    const conclusion = rule.conclusion;
+    for (let k = 0; k < conclusion.length; k++) {
+      const c = conclusion[k];
+      this._add(c.subject.value, c.predicate.value, c.object.value, content, c, cb);
+    }
+  }
+
+  // Bound values use direct lookups; unbound values scan the index
   _evaluatePremise(rule, content, cb, i = 0) {
-    let v1, v2, value, index1, index2;
+    let value, index1;
     const [val0, val1, val2] = rule.premise[i].value,
       index = content[rule.premise[i].content];
+    const last = i === rule.premise.length - 1;
     const v0 = !(value = val0.value);
-    for (value in v0 ? index : {
-      [value]: index[value]
-    }) {
-      if (index1 = index[value]) {
-        if (v0) val0.value = Number(value);
-        v1 = !(value = val1.value);
-        for (value in v1 ? index1 : {
-          [value]: index1[value]
-        }) {
-          if (index2 = index1[value]) {
-            if (v1) val1.value = Number(value);
-            v2 = !(value = val2.value);
-            for (value in v2 ? index2 : {
-              [value]: index2[value]
-            }) {
-              if (v2) val2.value = Number(value);
-              if (i === rule.premise.length - 1) rule.conclusion.forEach(c => {
-                // eslint-disable-next-line max-nested-callbacks
-                this._add(c.subject.value, c.predicate.value, c.object.value, content, () => {
-                  cb(c);
-                });
-              });else this._evaluatePremise(rule, content, cb, i + 1);
-            }
-            if (v2) val2.value = null;
-          }
-        }
-        if (v1) val1.value = null;
+    if (v0) {
+      // Intermediate index entries are always non-empty
+      for (value in index) {
+        index1 = index[value];
+        val0.value = Number(value);
+        this._evaluateLevel1(rule, content, cb, i, last, val1, val2, index1);
+      }
+      val0.value = null;
+    } else if (index1 = index[value]) {
+      this._evaluateLevel1(rule, content, cb, i, last, val1, val2, index1);
+    }
+  }
+  _evaluateLevel1(rule, content, cb, i, last, val1, val2, index1) {
+    let value, index2;
+    const v1 = !(value = val1.value);
+    if (v1) {
+      for (value in index1) {
+        index2 = index1[value];
+        val1.value = Number(value);
+        this._evaluateLevel2(rule, content, cb, i, last, val2, index2);
+      }
+      val1.value = null;
+    } else if (index2 = index1[value]) {
+      this._evaluateLevel2(rule, content, cb, i, last, val2, index2);
+    }
+  }
+  _evaluateLevel2(rule, content, cb, i, last, val2, index2) {
+    let value;
+    const v2 = !(value = val2.value);
+    if (v2) {
+      for (value in index2) {
+        val2.value = Number(value);
+        if (last) this._emit(rule, content, cb);else this._evaluatePremise(rule, content, cb, i + 1);
       }
+      val2.value = null;
     }
-    if (v0) val0.value = null;
+    // Bound leaves run once even when the key is absent
+    else if (last) this._emit(rule, content, cb);else this._evaluatePremise(rule, content, cb, i + 1);
   }
   _evaluateRules(rules, content, cb) {
     for (let i = 0; i < rules.length; i++) {
@@ -96,14 +116,12 @@ class N3Reasoner {
       });
     }
 
-    // eslint-disable-next-line func-style
+    // Reuse addRule instead of allocating a callback per conclusion
     const addConclusions = conclusion => {
-      conclusion.forEach(c => {
-        // eslint-disable-next-line max-nested-callbacks
-        this._add(c.subject.value, c.predicate.value, c.object.value, content, () => {
-          addRule(c);
-        });
-      });
+      for (let k = 0; k < conclusion.length; k++) {
+        const c = conclusion[k];
+        this._add(c.subject.value, c.predicate.value, c.object.value, content, c, addRule);
+      }
     };
     this._evaluateRules(rules, content, addRule);
     let r;
@@ -194,9 +212,7 @@ class N3Reasoner {
                 basePremise: p
               });
             }
-            r2.variables.forEach(v => {
-              v.value = null;
-            });
+            for (let k = 0; k < r2.variables.length; k++) r2.variables[k].value = null;
           }
         }
       }

package/lib/N3Store.js

@@ -14,14 +14,22 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
 // **N3Store** objects store N3 quads by graph in memory.
 
 const ITERATOR = Symbol('iter');
+const SIZE = Symbol('size');
 function hasInIndex(index0, key0, key1, key2) {
   const index1 = index0 && index0[key0];
   const index2 = index1 && index1[key1];
   return !!index2 && key2 in index2;
 }
 function merge(target, source, depth = 4) {
-  if (depth === 0) return Object.assign(target, source);
-  for (const key in source) target[key] = merge(target[key] || Object.create(null), source[key], depth - 1);
+  let size = target[SIZE] || 0;
+  for (const key in source) {
+    if (!(key in target)) {
+      size++;
+      target[key] = depth === 0 ? null : merge(Object.create(null), source[key], depth - 1);
+    } else if (depth !== 0) target[key] = merge(target[key], source[key], depth - 1);
+  }
+  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
+  if (depth <= 2) target[SIZE] = size;
   return target;
 }
 
@@ -33,13 +41,16 @@ function merge(target, source, depth = 4) {
  * *not* be set as the value for an index.
  */
 function intersect(s1, s2, depth = 4) {
-  let target = false;
+  let target = false,
+    size = 0;
+  if (depth <= 2 && s2[SIZE] < s1[SIZE]) [s1, s2] = [s2, s1];
   for (const key in s1) {
     if (key in s2) {
       const intersection = depth === 0 ? null : intersect(s1[key], s2[key], depth - 1);
       if (intersection !== false) {
         target = target || Object.create(null);
         target[key] = intersection;
+        size++;
       }
       // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
       // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
@@ -48,6 +59,9 @@ function intersect(s1, s2, depth = 4) {
       }
     }
   }
+
+  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
+  if (depth <= 2 && target) target[SIZE] = size;
   return target;
 }
 
@@ -59,18 +73,21 @@ function intersect(s1, s2, depth = 4) {
  * *not* be set as the value for an index.
  */
 function difference(s1, s2, depth = 4) {
-  let target = false;
+  let target = false,
+    size = 0;
   for (const key in s1) {
     // When the key is not in the index, then none of the triples defined by s1[key] are
     // in s2 and so we want to copy them over to the resultant store.
     if (!(key in s2)) {
       target = target || Object.create(null);
       target[key] = depth === 0 ? null : merge({}, s1[key], depth - 1);
+      size++;
     } else if (depth !== 0) {
       const diff = difference(s1[key], s2[key], depth - 1);
       if (diff !== false) {
         target = target || Object.create(null);
         target[key] = diff;
+        size++;
       }
       // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
       // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
@@ -79,6 +96,9 @@ function difference(s1, s2, depth = 4) {
       }
     }
   }
+
+  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
+  if (depth <= 2 && target) target[SIZE] = size;
   return target;
 }
 
@@ -178,7 +198,7 @@ class N3Store {
     size = 0;
     const graphs = this._graphs;
     let subjects, subject;
-    for (const graphKey in graphs) for (const subjectKey in subjects = graphs[graphKey].subjects) for (const predicateKey in subject = subjects[subjectKey]) size += Object.keys(subject[predicateKey]).length;
+    for (const graphKey in graphs) for (const subjectKey in subjects = graphs[graphKey].subjects) for (const predicateKey in subject = subjects[subjectKey]) size += subject[predicateKey][SIZE];
     return this._size = size;
   }
 
@@ -187,12 +207,27 @@ class N3Store {
   // ### `_addToIndex` adds a quad to a three-layered index.
   // Returns if the index has changed, if the entry did not already exist.
   _addToIndex(index0, key0, key1, key2) {
-    // Create layers as necessary
-    const index1 = index0[key0] || (index0[key0] = {});
-    const index2 = index1[key1] || (index1[key1] = {});
+    // Create layers as necessary, maintaining their entry counters
+    let index1 = index0[key0];
+    if (!index1) {
+      index0[key0] = index1 = {
+        [SIZE]: 0
+      };
+      index0[SIZE]++;
+    }
+    let index2 = index1[key1];
+    if (!index2) {
+      index1[key1] = index2 = {
+        [SIZE]: 0
+      };
+      index1[SIZE]++;
+    }
     // Setting the key to _any_ value signals the presence of the quad
     const existed = key2 in index2;
-    if (!existed) index2[key2] = null;
+    if (!existed) {
+      index2[key2] = null;
+      index2[SIZE]++;
+    }
     return !existed;
   }
 
@@ -203,11 +238,13 @@ class N3Store {
       index2 = index1[key1];
     delete index2[key2];
 
-    // Remove intermediary index layers if they are empty
-    for (const key in index2) return;
+    // Remove intermediary index layers if they are empty,
+    // which the entry counters detect in constant time
+    if (--index2[SIZE] !== 0) return;
     delete index1[key1];
-    for (const key in index1) return;
+    if (--index1[SIZE] !== 0) return;
     delete index0[key0];
+    index0[SIZE]--;
   }
 
   // ### `_findInIndex` finds a set of quads in a three-layered index.
@@ -312,7 +349,7 @@ class N3Store {
             // If a key is specified, count the quad if it exists
             if (key2) key2 in index2 && count++;
             // Otherwise, count all quads
-            else count += Object.keys(index2).length;
+            else count += index2[SIZE];
           }
         }
       }
@@ -365,9 +402,15 @@ class N3Store {
     // Create the graph if it doesn't exist yet
     if (!graphItem) {
       graphItem = this._graphs[graph] = {
-        subjects: {},
-        predicates: {},
-        objects: {}
+        subjects: {
+          [SIZE]: 0
+        },
+        predicates: {
+          [SIZE]: 0
+        },
+        objects: {
+          [SIZE]: 0
+        }
       };
       // Freezing a graph helps subsequent `add` performance,
       // and properties will never be modified anyway
@@ -454,8 +497,7 @@ class N3Store {
     if (this._size !== null) this._size--;
 
     // Remove the graph if it is empty
-    for (subject in graphItem.subjects) return true;
-    delete graphs[graph];
+    if (graphItem.subjects[SIZE] === 0) delete graphs[graph];
     return true;
   }
 
@@ -1062,7 +1104,8 @@ exports.default = N3Store;
 function indexMatch(index, ids, depth = 0) {
   const ind = ids[depth];
   if (ind && !(ind in index)) return false;
-  let target = false;
+  let target = false,
+    size = 0;
   for (const key in ind ? {
     [ind]: index[ind]
   } : index) {
@@ -1070,8 +1113,10 @@ function indexMatch(index, ids, depth = 0) {
     if (result !== false) {
       target = target || Object.create(null);
       target[key] = result;
+      size++;
     }
   }
+  if (target) target[SIZE] = size;
   return target;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "2.2.8",
+  "version": "2.2.10",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [

package/src/N3Reasoner.js

@@ -22,7 +22,7 @@ export default class N3Reasoner {
     this._maxPremiseDepth = options.maxPremiseDepth === undefined ? Infinity : options.maxPremiseDepth;
   }
 
-  _add(subject, predicate, object, graphItem, cb) {
+  _add(subject, predicate, object, graphItem, c, cb) {
     // Only add to the remaining indexes if there is not already a value in the index
     if (!this._store._addToIndex(graphItem.subjects,   subject,   predicate, object)) return;
     this._store._addToIndex(graphItem.predicates, predicate, object,    subject);
@@ -32,39 +32,68 @@ export default class N3Reasoner {
     // in a consistent state (the reasoning result is merely incomplete).
     if (++this._derivations > this._maxDerivations)
       throw new Error(`Reasoning exceeded the maximum of ${this._maxDerivations} derivations`);
-    cb();
+    cb(c);
   }
 
+  // Emit conclusions without allocating per-match callbacks
+  _emit(rule, content, cb) {
+    const conclusion = rule.conclusion;
+    for (let k = 0; k < conclusion.length; k++) {
+      const c = conclusion[k];
+      this._add(c.subject.value, c.predicate.value, c.object.value, content, c, cb);
+    }
+  }
+
+  // Bound values use direct lookups; unbound values scan the index
   _evaluatePremise(rule, content, cb, i = 0) {
-    let v1, v2, value, index1, index2;
+    let value, index1;
     const [val0, val1, val2] = rule.premise[i].value, index = content[rule.premise[i].content];
+    const last = i === rule.premise.length - 1;
     const v0 = !(value = val0.value);
-    for (value in v0 ? index : { [value]: index[value] }) {
-      if (index1 = index[value]) {
-        if (v0) val0.value = Number(value);
-        v1 = !(value = val1.value);
-        for (value in v1 ? index1 : { [value]: index1[value] }) {
-          if (index2 = index1[value]) {
-            if (v1) val1.value = Number(value);
-            v2 = !(value = val2.value);
-            for (value in v2 ? index2 : { [value]: index2[value] }) {
-              if (v2) val2.value = Number(value);
-
-              if (i === rule.premise.length - 1)
-                rule.conclusion.forEach(c => {
-                  // eslint-disable-next-line max-nested-callbacks
-                  this._add(c.subject.value, c.predicate.value, c.object.value, content, () => { cb(c); });
-                });
-              else
-                this._evaluatePremise(rule, content, cb, i + 1);
-            }
-            if (v2) val2.value = null;
-          }
-        }
-        if (v1) val1.value = null;
+    if (v0) {
+      // Intermediate index entries are always non-empty
+      for (value in index) {
+        index1 = index[value];
+        val0.value = Number(value);
+        this._evaluateLevel1(rule, content, cb, i, last, val1, val2, index1);
+      }
+      val0.value = null;
+    }
+    else if (index1 = index[value]) {
+      this._evaluateLevel1(rule, content, cb, i, last, val1, val2, index1);
+    }
+  }
+
+  _evaluateLevel1(rule, content, cb, i, last, val1, val2, index1) {
+    let value, index2;
+    const v1 = !(value = val1.value);
+    if (v1) {
+      for (value in index1) {
+        index2 = index1[value];
+        val1.value = Number(value);
+        this._evaluateLevel2(rule, content, cb, i, last, val2, index2);
       }
+      val1.value = null;
+    }
+    else if (index2 = index1[value]) {
+      this._evaluateLevel2(rule, content, cb, i, last, val2, index2);
     }
-    if (v0) val0.value = null;
+  }
+
+  _evaluateLevel2(rule, content, cb, i, last, val2, index2) {
+    let value;
+    const v2 = !(value = val2.value);
+    if (v2) {
+      for (value in index2) {
+        val2.value = Number(value);
+        if (last) this._emit(rule, content, cb);
+        else this._evaluatePremise(rule, content, cb, i + 1);
+      }
+      val2.value = null;
+    }
+    // Bound leaves run once even when the key is absent
+    else if (last) this._emit(rule, content, cb);
+    else this._evaluatePremise(rule, content, cb, i + 1);
   }
 
   _evaluateRules(rules, content, cb) {
@@ -85,12 +114,12 @@ export default class N3Reasoner {
         });
     }
 
-    // eslint-disable-next-line func-style
+    // Reuse addRule instead of allocating a callback per conclusion
     const addConclusions = conclusion => {
-      conclusion.forEach(c => {
-        // eslint-disable-next-line max-nested-callbacks
-        this._add(c.subject.value, c.predicate.value, c.object.value, content, () => { addRule(c); });
-      });
+      for (let k = 0; k < conclusion.length; k++) {
+        const c = conclusion[k];
+        this._add(c.subject.value, c.predicate.value, c.object.value, content, c, addRule);
+      }
     };
 
     this._evaluateRules(rules, content, addRule);
@@ -185,7 +214,7 @@ export default class N3Reasoner {
                 basePremise: p,
               });
             }
-            r2.variables.forEach(v => { v.value = null; });
+            for (let k = 0; k < r2.variables.length; k++) r2.variables[k].value = null;
           }
         }
       }

package/src/N3Store.js

@@ -6,6 +6,7 @@ import { isDefaultGraph } from './N3Util';
 import N3Writer from './N3Writer';
 
 const ITERATOR = Symbol('iter');
+const SIZE = Symbol('size');
 
 function hasInIndex(index0, key0, key1, key2) {
   const index1 = index0 && index0[key0];
@@ -14,11 +15,18 @@ function hasInIndex(index0, key0, key1, key2) {
 }
 
 function merge(target, source, depth = 4) {
-  if (depth === 0)
-    return Object.assign(target, source);
-
-  for (const key in source)
-    target[key] = merge(target[key] || Object.create(null), source[key], depth - 1);
+  let size = target[SIZE] || 0;
+  for (const key in source) {
+    if (!(key in target)) {
+      size++;
+      target[key] = depth === 0 ? null : merge(Object.create(null), source[key], depth - 1);
+    }
+    else if (depth !== 0)
+      target[key] = merge(target[key], source[key], depth - 1);
+  }
+  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
+  if (depth <= 2)
+    target[SIZE] = size;
 
   return target;
 }
@@ -31,7 +39,10 @@ function merge(target, source, depth = 4) {
  * *not* be set as the value for an index.
  */
 function intersect(s1, s2, depth = 4) {
-  let target = false;
+  let target = false, size = 0;
+
+  if (depth <= 2 && s2[SIZE] < s1[SIZE])
+    [s1, s2] = [s2, s1];
 
   for (const key in s1) {
     if (key in s2) {
@@ -39,6 +50,7 @@ function intersect(s1, s2, depth = 4) {
       if (intersection !== false) {
         target = target || Object.create(null);
         target[key] = intersection;
+        size++;
       }
       // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
       // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
@@ -48,6 +60,10 @@ function intersect(s1, s2, depth = 4) {
     }
   }
 
+  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
+  if (depth <= 2 && target)
+    target[SIZE] = size;
+
   return target;
 }
 
@@ -59,7 +75,7 @@ function intersect(s1, s2, depth = 4) {
  * *not* be set as the value for an index.
  */
 function difference(s1, s2, depth = 4) {
-  let target = false;
+  let target = false, size = 0;
 
   for (const key in s1) {
     // When the key is not in the index, then none of the triples defined by s1[key] are
@@ -67,12 +83,14 @@ function difference(s1, s2, depth = 4) {
     if (!(key in s2)) {
       target = target || Object.create(null);
       target[key] = depth === 0 ? null : merge({}, s1[key], depth - 1);
+      size++;
     }
     else if (depth !== 0) {
       const diff = difference(s1[key], s2[key], depth - 1);
       if (diff !== false) {
         target = target || Object.create(null);
         target[key] = diff;
+        size++;
       }
       // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
       // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
@@ -82,6 +100,10 @@ function difference(s1, s2, depth = 4) {
     }
   }
 
+  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
+  if (depth <= 2 && target)
+    target[SIZE] = size;
+
   return target;
 }
 
@@ -200,7 +222,7 @@ export default class N3Store {
     for (const graphKey in graphs)
       for (const subjectKey in (subjects = graphs[graphKey].subjects))
         for (const predicateKey in (subject = subjects[subjectKey]))
-          size += Object.keys(subject[predicateKey]).length;
+          size += subject[predicateKey][SIZE];
     return this._size = size;
   }
 
@@ -209,13 +231,23 @@ export default class N3Store {
   // ### `_addToIndex` adds a quad to a three-layered index.
   // Returns if the index has changed, if the entry did not already exist.
   _addToIndex(index0, key0, key1, key2) {
-    // Create layers as necessary
-    const index1 = index0[key0] || (index0[key0] = {});
-    const index2 = index1[key1] || (index1[key1] = {});
+    // Create layers as necessary, maintaining their entry counters
+    let index1 = index0[key0];
+    if (!index1) {
+      index0[key0] = index1 = { [SIZE]: 0 };
+      index0[SIZE]++;
+    }
+    let index2 = index1[key1];
+    if (!index2) {
+      index1[key1] = index2 = { [SIZE]: 0 };
+      index1[SIZE]++;
+    }
     // Setting the key to _any_ value signals the presence of the quad
     const existed = key2 in index2;
-    if (!existed)
+    if (!existed) {
       index2[key2] = null;
+      index2[SIZE]++;
+    }
     return !existed;
   }
 
@@ -225,11 +257,13 @@ export default class N3Store {
     const index1 = index0[key0], index2 = index1[key1];
     delete index2[key2];
 
-    // Remove intermediary index layers if they are empty
-    for (const key in index2) return;
+    // Remove intermediary index layers if they are empty,
+    // which the entry counters detect in constant time
+    if (--index2[SIZE] !== 0) return;
     delete index1[key1];
-    for (const key in index1) return;
+    if (--index1[SIZE] !== 0) return;
     delete index0[key0];
+    index0[SIZE]--;
   }
 
   // ### `_findInIndex` finds a set of quads in a three-layered index.
@@ -332,7 +366,7 @@ export default class N3Store {
             // If a key is specified, count the quad if it exists
             if (key2) (key2 in index2) && count++;
             // Otherwise, count all quads
-            else count += Object.keys(index2).length;
+            else count += index2[SIZE];
           }
         }
       }
@@ -384,7 +418,11 @@ export default class N3Store {
     let graphItem = this._graphs[graph];
     // Create the graph if it doesn't exist yet
     if (!graphItem) {
-      graphItem = this._graphs[graph] = { subjects: {}, predicates: {}, objects: {} };
+      graphItem = this._graphs[graph] = {
+        subjects: { [SIZE]: 0 },
+        predicates: { [SIZE]: 0 },
+        objects: { [SIZE]: 0 },
+      };
       // Freezing a graph helps subsequent `add` performance,
       // and properties will never be modified anyway
       Object.freeze(graphItem);
@@ -469,8 +507,8 @@ export default class N3Store {
     if (this._size !== null) this._size--;
 
     // Remove the graph if it is empty
-    for (subject in graphItem.subjects) return true;
-    delete graphs[graph];
+    if (graphItem.subjects[SIZE] === 0)
+      delete graphs[graph];
     return true;
   }
 
@@ -1130,15 +1168,18 @@ function indexMatch(index, ids, depth = 0) {
   if (ind && !(ind in index))
     return false;
 
-  let target = false;
+  let target = false, size = 0;
   for (const key in (ind ? { [ind]: index[ind] } : index)) {
     const result = depth === 2 ? null : indexMatch(index[key], ids, depth + 1);
 
     if (result !== false) {
       target = target || Object.create(null);
       target[key] = result;
+      size++;
     }
   }
+  if (target)
+    target[SIZE] = size;
   return target;
 }