n3 1.18.0 → 1.20.0

package/lib/N3Reasoner.js

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getRulesFromDataset = getRulesFromDataset;
+var _N3DataFactory = _interopRequireDefault(require("./N3DataFactory"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Gets rules from a dataset. This will only collect horn rules declared using log:implies.
+ */
+function getRulesFromDataset(dataset) {
+  const rules = [];
+  for (const {
+    subject,
+    object
+  } of dataset.match(null, _N3DataFactory.default.namedNode('http://www.w3.org/2000/10/swap/log#implies'), null, _N3DataFactory.default.defaultGraph())) {
+    const premise = [...dataset.match(null, null, null, subject)];
+    const conclusion = [...dataset.match(null, null, null, object)];
+    rules.push({
+      premise,
+      conclusion
+    });
+  }
+  return rules;
+}
+class N3Reasoner {
+  constructor(store) {
+    this._store = store;
+  }
+  _add(subject, predicate, object, graphItem, 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);
+    this._store._addToIndex(graphItem.objects, object, subject, predicate);
+    cb();
+  }
+
+  // eslint-disable-next-line no-warning-comments
+  _evaluatePremise(rule, content, cb, i = 0) {
+    let v1, v2, value, index1, index2;
+    const [val0, val1, val2] = rule.premise[i].value,
+      index = content[rule.premise[i].content];
+    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) val0.value = null;
+  }
+  _evaluateRules(rules, content, cb) {
+    for (let i = 0; i < rules.length; i++) {
+      this._evaluatePremise(rules[i], content, cb);
+    }
+  }
+
+  // A naive reasoning algorithm where rules are just applied by repeatedly applying rules
+  // until no more evaluations are made
+  _reasonGraphNaive(rules, content) {
+    const newRules = [];
+    function addRule(conclusion) {
+      if (conclusion.next) conclusion.next.forEach(rule => {
+        newRules.push([conclusion.subject.value, conclusion.predicate.value, conclusion.object.value, rule]);
+      });
+    }
+
+    // eslint-disable-next-line func-style
+    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);
+        });
+      });
+    };
+    this._evaluateRules(rules, content, addRule);
+    let r;
+    while ((r = newRules.pop()) !== undefined) {
+      const [subject, predicate, object, rule] = r;
+      const v1 = rule.basePremise.subject.value;
+      if (!v1) rule.basePremise.subject.value = subject;
+      const v2 = rule.basePremise.predicate.value;
+      if (!v2) rule.basePremise.predicate.value = predicate;
+      const v3 = rule.basePremise.object.value;
+      if (!v3) rule.basePremise.object.value = object;
+      if (rule.premise.length === 0) {
+        addConclusions(rule.conclusion);
+      } else {
+        this._evaluatePremise(rule, content, addRule);
+      }
+      if (!v1) rule.basePremise.subject.value = null;
+      if (!v2) rule.basePremise.predicate.value = null;
+      if (!v3) rule.basePremise.object.value = null;
+    }
+  }
+  _createRule({
+    premise,
+    conclusion
+  }) {
+    const varMapping = {};
+    const toId = value => value.termType === 'Variable' ?
+    // If the term is a variable, then create an empty object that values can be placed into
+    varMapping[value.value] = varMapping[value.value] || {} :
+    // If the term is not a variable, then set the ID value
+    {
+      value: this._store._termToNewNumericId(value)
+    };
+
+    // eslint-disable-next-line func-style
+    const t = term => ({
+      subject: toId(term.subject),
+      predicate: toId(term.predicate),
+      object: toId(term.object)
+    });
+    return {
+      premise: premise.map(p => t(p)),
+      conclusion: conclusion.map(p => t(p)),
+      variables: Object.values(varMapping)
+    };
+  }
+  reason(rules) {
+    if (!Array.isArray(rules)) {
+      rules = getRulesFromDataset(rules);
+    }
+    rules = rules.map(rule => this._createRule(rule));
+    for (const r1 of rules) {
+      for (const r2 of rules) {
+        for (let i = 0; i < r2.premise.length; i++) {
+          const p = r2.premise[i];
+          for (const c of r1.conclusion) {
+            if (termEq(p.subject, c.subject) && termEq(p.predicate, c.predicate) && termEq(p.object, c.object)) {
+              const set = new Set();
+              const premise = [];
+
+              // Since these *will* be substituted when we apply the rule,
+              // we need to do this, so that we index correctly in the subsequent section
+              p.subject.value = p.subject.value || 1;
+              p.object.value = p.object.value || 1;
+              p.predicate.value = p.predicate.value || 1;
+              for (let j = 0; j < r2.premise.length; j++) {
+                if (j !== i) {
+                  premise.push(getIndex(r2.premise[j], set));
+                }
+              }
+
+              // eslint-disable-next-line no-warning-comments
+              // TODO: Create new rule, with new indexing
+              //       Future, 'collapse' the next statements when they share a premise/base-premise
+              (c.next = c.next || []).push({
+                premise,
+                conclusion: r2.conclusion,
+                // This is a single premise of the form { subject, predicate, object },
+                // which we can use to instantiate the rule using the new data that was emitted
+                basePremise: p
+              });
+            }
+            r2.variables.forEach(v => {
+              v.value = null;
+            });
+          }
+        }
+      }
+    }
+    for (const rule of rules) {
+      const set = new Set();
+      rule.premise = rule.premise.map(p => getIndex(p, set));
+    }
+    const graphs = this._store._getGraphs();
+    for (const graphId in graphs) {
+      this._reasonGraphNaive(rules, graphs[graphId]);
+    }
+    this._store._size = null;
+  }
+}
+exports.default = N3Reasoner;
+function getIndex({
+  subject,
+  predicate,
+  object
+}, set) {
+  const s = subject.value || set.has(subject) || (set.add(subject), false);
+  const p = predicate.value || set.has(predicate) || (set.add(predicate), false);
+  const o = object.value || set.has(object) || (set.add(object), false);
+  return !s && p ? {
+    content: 'predicates',
+    value: [predicate, object, subject]
+  } : o ? {
+    content: 'objects',
+    value: [object, subject, predicate]
+  } : {
+    content: 'subjects',
+    value: [subject, predicate, object]
+  };
+}
+function termEq(t1, t2) {
+  if (t1.value === null) {
+    t1.value = t2.value;
+  }
+  return t1.value === t2.value;
+}

package/lib/N3Store.js

@@ -8,6 +8,7 @@ var _readableStream = require("readable-stream");
 var _N3DataFactory = _interopRequireWildcard(require("./N3DataFactory"));
 var _IRIs = _interopRequireDefault(require("./IRIs"));
 var _N3Util = require("./N3Util");
+var _N3Writer = _interopRequireDefault(require("./N3Writer"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -495,7 +496,7 @@ class N3Store {
   // Setting any field to `undefined` or `null` indicates a wildcard.
   forEach(callback, subject, predicate, object, graph) {
     this.some(quad => {
-      callback(quad);
+      callback(quad, this);
       return false;
     }, subject, predicate, object, graph);
   }
@@ -504,12 +505,7 @@ class N3Store {
   // and returns `true` if it returns truthy for all them.
   // Setting any field to `undefined` or `null` indicates a wildcard.
   every(callback, subject, predicate, object, graph) {
-    let some = false;
-    const every = !this.some(quad => {
-      some = true;
-      return !callback(quad);
-    }, subject, predicate, object, graph);
-    return some && every;
+    return !this.some(quad => !callback(quad, this), subject, predicate, object, graph);
   }
 
   // ### `some` executes the callback on all quads,
@@ -743,6 +739,149 @@ class N3Store {
     return lists;
   }
 
+  /**
+   * Returns `true` if the current dataset is a superset of the given dataset; in other words, returns `true` if
+   * the given dataset is a subset of, i.e., is contained within, the current dataset.
+   *
+   * Blank Nodes will be normalized.
+   */
+  addAll(quads) {
+    if (Array.isArray(quads)) this.addQuads(quads);else {
+      for (const quad of quads) this.add(quad);
+    }
+    return this;
+  }
+
+  /**
+   * Returns `true` if the current dataset is a superset of the given dataset; in other words, returns `true` if
+   * the given dataset is a subset of, i.e., is contained within, the current dataset.
+   *
+   * Blank Nodes will be normalized.
+   */
+  contains(other) {
+    return other.every(quad => this.has(quad));
+  }
+
+  /**
+   * This method removes the quads in the current dataset that match the given arguments.
+   *
+   * The logic described in {@link https://rdf.js.org/dataset-spec/#quad-matching|Quad Matching} is applied for each
+   * quad in this dataset, to select the quads which will be deleted.
+   *
+   * @param subject   The optional exact subject to match.
+   * @param predicate The optional exact predicate to match.
+   * @param object    The optional exact object to match.
+   * @param graph     The optional exact graph to match.
+   */
+  deleteMatches(subject, predicate, object, graph) {
+    for (const quad of this.match(subject, predicate, object, graph)) this.removeQuad(quad);
+    return this;
+  }
+
+  /**
+   * Returns a new dataset that contains all quads from the current dataset that are not included in the given dataset.
+   */
+  difference(other) {
+    return this.filter(quad => !other.has(quad));
+  }
+
+  /**
+   * Returns true if the current dataset contains the same graph structure as the given dataset.
+   *
+   * Blank Nodes will be normalized.
+   */
+  equals(other) {
+    return other === this || this.size === other.size && this.contains(other);
+  }
+
+  /**
+   * Creates a new dataset with all the quads that pass the test implemented by the provided `iteratee`.
+   *
+   * This method is aligned with Array.prototype.filter() in ECMAScript-262.
+   */
+  filter(iteratee) {
+    const store = new N3Store();
+    for (const quad of this) if (iteratee(quad, this)) store.add(quad);
+    return store;
+  }
+
+  /**
+   * Returns a new dataset containing all quads from the current dataset that are also included in the given dataset.
+   */
+  intersection(other) {
+    return this.filter(quad => other.has(quad));
+  }
+
+  /**
+   * Returns a new dataset containing all quads returned by applying `iteratee` to each quad in the current dataset.
+   */
+  map(iteratee) {
+    const store = new N3Store();
+    for (const quad of this) store.add(iteratee(quad, this));
+    return store;
+  }
+
+  /**
+   * This method calls the `iteratee` method on each `quad` of the `Dataset`. The first time the `iteratee` method
+   * is called, the `accumulator` value is the `initialValue`, or, if not given, equals the first quad of the `Dataset`.
+   * The return value of each call to the `iteratee` method is used as the `accumulator` value for the next call.
+   *
+   * This method returns the return value of the last `iteratee` call.
+   *
+   * This method is aligned with `Array.prototype.reduce()` in ECMAScript-262.
+   */
+  reduce(callback, initialValue) {
+    const iter = this.readQuads();
+    let accumulator = initialValue === undefined ? iter.next().value : initialValue;
+    for (const quad of iter) accumulator = callback(accumulator, quad, this);
+    return accumulator;
+  }
+
+  /**
+   * Returns the set of quads within the dataset as a host-language-native sequence, for example an `Array` in
+   * ECMAScript-262.
+   *
+   * Since a `Dataset` is an unordered set, the order of the quads within the returned sequence is arbitrary.
+   */
+  toArray() {
+    return this.getQuads();
+  }
+
+  /**
+   * Returns an N-Quads string representation of the dataset, preprocessed with the
+   * {@link https://json-ld.github.io/normalization/spec/|RDF Dataset Normalization} algorithm.
+   */
+  toCanonical() {
+    throw new Error('not implemented');
+  }
+
+  /**
+   * Returns a stream that contains all quads of the dataset.
+   */
+  toStream() {
+    return this.match();
+  }
+
+  /**
+   * Returns an N-Quads string representation of the dataset.
+   *
+   * No prior normalization is required, therefore the results for the same quads may vary depending on the `Dataset`
+   * implementation.
+   */
+  toString() {
+    return new _N3Writer.default().quadsToString(this);
+  }
+
+  /**
+   * Returns a new `Dataset` that is a concatenation of this dataset and the quads given as an argument.
+   */
+  union(quads) {
+    const store = new N3Store();
+    store.addAll(this);
+    store.addAll(quads);
+    return store;
+  }
+
   // ### Store is an iterable.
   // Can be used where iterables are expected: for...of loops, array spread operator,
   // `yield*`, and destructuring assignment (order is not guaranteed).
@@ -804,6 +943,60 @@ class DatasetCoreAndReadableStream extends _readableStream.Readable {
       this.push(value);
     }
   }
+  addAll(quads) {
+    return this.filtered.addAll(quads);
+  }
+  contains(other) {
+    return this.filtered.contains(other);
+  }
+  deleteMatches(subject, predicate, object, graph) {
+    return this.filtered.deleteMatches(subject, predicate, object, graph);
+  }
+  difference(other) {
+    return this.filtered.difference(other);
+  }
+  equals(other) {
+    return this.filtered.equals(other);
+  }
+  every(callback, subject, predicate, object, graph) {
+    return this.filtered.every(callback, subject, predicate, object, graph);
+  }
+  filter(iteratee) {
+    return this.filtered.filter(iteratee);
+  }
+  forEach(callback, subject, predicate, object, graph) {
+    return this.filtered.forEach(callback, subject, predicate, object, graph);
+  }
+  import(stream) {
+    return this.filtered.import(stream);
+  }
+  intersection(other) {
+    return this.filtered.intersection(other);
+  }
+  map(iteratee) {
+    return this.filtered.map(iteratee);
+  }
+  some(callback, subject, predicate, object, graph) {
+    return this.filtered.some(callback, subject, predicate, object, graph);
+  }
+  toCanonical() {
+    return this.filtered.toCanonical();
+  }
+  toStream() {
+    return this._filtered ? this._filtered.toStream() : this.n3Store.match(this.subject, this.predicate, this.object, this.graph);
+  }
+  union(quads) {
+    return this._filtered ? this._filtered.union(quads) : this.n3Store.match(this.subject, this.predicate, this.object, this.graph).addAll(quads);
+  }
+  toArray() {
+    return this._filtered ? this._filtered.toArray() : this.n3Store.getQuads(this.subject, this.predicate, this.object, this.graph);
+  }
+  reduce(callback, initialValue) {
+    return this.filtered.reduce(callback, initialValue);
+  }
+  toString() {
+    return new _N3Writer.default().quadsToString(this);
+  }
   add(quad) {
     return this.filtered.add(quad);
   }

package/lib/N3Writer.js

@@ -136,9 +136,9 @@ class N3Writer {
 
   // ### `quadsToString` serializes an array of quads as a string
   quadsToString(quads) {
-    return quads.map(t => {
-      return this.quadToString(t.subject, t.predicate, t.object, t.graph);
-    }).join('');
+    let quadsString = '';
+    for (const quad of quads) quadsString += this.quadToString(quad.subject, quad.predicate, quad.object, quad.graph);
+    return quadsString;
   }
 
   // ### `_encodeSubject` represents a subject

package/lib/index.js

@@ -57,6 +57,12 @@ Object.defineProperty(exports, "Quad", {
     return _N3DataFactory.Quad;
   }
 });
+Object.defineProperty(exports, "Reasoner", {
+  enumerable: true,
+  get: function () {
+    return _N3Reasoner.default;
+  }
+});
 Object.defineProperty(exports, "Store", {
   enumerable: true,
   get: function () {
@@ -107,6 +113,12 @@ Object.defineProperty(exports, "Writer", {
   }
 });
 exports.default = void 0;
+Object.defineProperty(exports, "getRulesFromDataset", {
+  enumerable: true,
+  get: function () {
+    return _N3Reasoner.getRulesFromDataset;
+  }
+});
 Object.defineProperty(exports, "termFromId", {
   enumerable: true,
   get: function () {
@@ -124,6 +136,7 @@ var _N3Parser = _interopRequireDefault(require("./N3Parser"));
 var _N3Writer = _interopRequireDefault(require("./N3Writer"));
 var _N3Store = _interopRequireWildcard(require("./N3Store"));
 var _N3StoreFactory = _interopRequireDefault(require("./N3StoreFactory"));
+var _N3Reasoner = _interopRequireWildcard(require("./N3Reasoner"));
 var _N3StreamParser = _interopRequireDefault(require("./N3StreamParser"));
 var _N3StreamWriter = _interopRequireDefault(require("./N3StreamWriter"));
 var Util = _interopRequireWildcard(require("./N3Util"));
@@ -144,6 +157,7 @@ var _default = exports.default = {
   StreamParser: _N3StreamParser.default,
   StreamWriter: _N3StreamWriter.default,
   Util,
+  Reasoner: _N3Reasoner.default,
   DataFactory: _N3DataFactory.default,
   Term: _N3DataFactory.Term,
   NamedNode: _N3DataFactory.NamedNode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [
@@ -37,6 +37,7 @@
     "arrayify-stream": "^1.0.0",
     "browserify": "^17.0.0",
     "colors": "^1.1.2",
+    "deep-taxonomy-benchmark": "^1.2.0",
     "docco": "^0.9.1",
     "eslint": "^5.14.1",
     "eslint-plugin-import": "^2.29.1",