n3 2.7.1 → 2.7.3

package/lib/N3Lexer.js

@@ -322,11 +322,11 @@ class N3Lexer {
         case 'h':
         case 'o':
           // Try to find an N3 verb keyword
-          if (this._n3Mode && (match = this._n3Verb.exec(input))) type = match[0];else inconclusive = true;
+          if (this._n3Mode && (match = this._matchN3Verb(input, inputFinished))) type = match[0];else inconclusive = true;
           break;
         case 'i':
           // Try to find an IRI property list identifier or N3 verb keyword
-          if (this._n3Mode && (match = this._n3Id.exec(input))) type = 'id';else if (this._n3Mode && (match = this._n3Verb.exec(input))) type = match[0];else inconclusive = true;
+          if (this._n3Mode && (match = this._n3Id.exec(input))) type = 'id';else if (this._n3Mode && (match = this._matchN3Verb(input, inputFinished))) type = match[0];else inconclusive = true;
           break;
         case '=':
           // Try to find an implication arrow or equals sign
@@ -438,6 +438,29 @@ class N3Lexer {
     }
   }
 
+  // ### `_matchN3Verb` matches an N3 verb unless the input is a longer prefixed name
+  _matchN3Verb(input, inputFinished) {
+    const verb = this._n3Verb.exec(input);
+    if (!verb) return null;
+
+    // Most verb boundaries cannot be part of a prefix, so keep the common path fast.
+    const next = input[verb[0].length];
+    if (next !== '-' && next !== '_' && (next < '0' || next > '9')) return verb;
+
+    // A prefix can start with a verb and continue with characters that are also
+    // valid verb boundaries. Prefer the longer prefixed name when it is complete.
+    if (this._prefixed.exec(input) || this._prefixed.exec(`${input} `)) return null;
+
+    // If a stream chunk ends partway through such a prefix, wait for the colon
+    // instead of prematurely emitting the verb. Appending ": " lets the prefix
+    // grammar determine whether all input seen so far can be a complete prefix.
+    if (!inputFinished) {
+      const prefix = this._prefix.exec(`${input}: `);
+      if (prefix) return null;
+    }
+    return verb;
+  }
+
   // ### `_unescape` replaces N3 escape codes by their corresponding characters,
   // allowing only the fixed escape sequences from the given replacement table
   _unescape(item, replacements) {

package/lib/N3Parser.js

@@ -31,6 +31,13 @@ class N3Parser {
       isNQuads = /quad/.test(format),
       isN3 = this._n3Mode = /n3/.test(format),
       isLineMode = isNTriples || isNQuads;
+    // Keep inverse handling off the non-N3 emission path
+    this._emitCurrent = this._emit;
+    if (isN3) {
+      this._createQuad = this._createQuadInDirection;
+      this._emit = this._emitInDirection;
+      this._emitCurrent = this._emitCurrentInDirection;
+    }
     if (!(this._supportsNamedGraphs = !(isTurtle || isN3))) this._readPredicateOrNamedGraph = this._readPredicate;
     // Support triples in other graphs
     this._supportsQuads = !(isTurtle || isTriG || isNTriples || isN3);
@@ -514,7 +521,7 @@ class N3Parser {
     if (token.type !== ']') return this._readBlankNodePunctuation(token);
 
     // Store blank node quad
-    if (this._subject !== null) this._emit(this._subject, this._predicate, this._object, this._graph);
+    if (this._subject !== null) this._emitCurrent(this._subject, this._predicate, this._object, this._graph);
 
     // Restore the parent context containing this blank node
     const empty = this._predicate === null;
@@ -841,7 +848,7 @@ class N3Parser {
     if (token.type !== '}') return this._readPunctuation(token);
 
     // Store the last quad of the formula
-    if (this._subject !== null) this._emit(this._subject, this._predicate, this._object, this._graph);
+    if (this._subject !== null) this._emitCurrent(this._subject, this._predicate, this._object, this._graph);
     const formula = this._graph,
       empty = this._emptyFormula;
     // Restore the parent context containing this formula
@@ -882,6 +889,7 @@ class N3Parser {
         break;
       // Semicolon means the subject is shared; predicate and object are different
       case ';':
+        if (inversePredicate) this._inversePredicate = false;
         next = this._readPredicate;
         break;
       // Comma means both the subject and predicate are shared; the object is different
@@ -902,6 +910,7 @@ class N3Parser {
         // Same staleness rule as ~ above.
         if (subject !== null) this._tripleTerm = null;
         this._subject = this._readTripleTerm();
+        this._inversePredicate = false;
         this._validAnnotation = false;
         startingAnnotation = true;
         next = this._readPredicate;
@@ -912,6 +921,7 @@ class N3Parser {
         if (!this._validAnnotation) return this._error('Annotation block can not be empty', token);
         this._subject = null;
         this._annotation = false;
+        this._inversePredicate = false;
         next = this._getContextEndReader();
         break;
       default:
@@ -926,7 +936,7 @@ class N3Parser {
     if (subject !== null && (!startingAnnotation || startingAnnotation && !this._annotation)) {
       const predicate = this._predicate,
         object = this._object;
-      if (!inversePredicate) this._emit(subject, predicate, object, graph);else this._emit(object, predicate, subject, graph);
+      this._emit(subject, predicate, object, graph, inversePredicate);
     }
     if (startingAnnotation) {
       this._annotation = true;
@@ -936,10 +946,12 @@ class N3Parser {
 
   // ### `_readBlankNodePunctuation` reads punctuation in a blank node
   _readBlankNodePunctuation(token) {
-    let next;
+    let next,
+      resetInversePredicate = false;
     switch (token.type) {
       // Semicolon means the subject is shared; predicate and object are different
       case ';':
+        resetInversePredicate = this._inversePredicate;
         next = this._readPredicate;
         break;
       // Comma means both the subject and predicate are shared; the object is different
@@ -961,7 +973,8 @@ class N3Parser {
     // nothing left to share with a following predicate-object pair
     if (this._subject === null) return this._error('Expected ] to follow annotation', token);
     // A quad has been completed now, so return it
-    this._emit(this._subject, this._predicate, this._object, this._graph);
+    this._emitCurrent(this._subject, this._predicate, this._object, this._graph);
+    if (resetInversePredicate) this._inversePredicate = false;
     return next;
   }
 
@@ -1158,7 +1171,7 @@ class N3Parser {
   _readTripleTermTail(token) {
     if (token.type !== ')>>') return this._error(`Expected )>> but got ${token.type}`, token);
     // Read the quad and restore the previous context
-    const quad = this._factory.quad(this._subject, this._predicate, this._object, this._graph || this.DEFAULTGRAPH);
+    const quad = this._createQuad(this._subject, this._predicate, this._object, this._graph, this._inversePredicate);
     this._restoreContext('<<(', token);
 
     // If we're in a list, continue processing that list
@@ -1257,6 +1270,7 @@ class N3Parser {
     switch (token.type) {
       // The subject stays shared with the next predicate-object pair
       case ';':
+        this._inversePredicate = false;
         return this._readPredicate;
       // The subject and predicate stay shared with the next object
       case ',':
@@ -1274,7 +1288,7 @@ class N3Parser {
     const parentGraph = parent ? parent.graph : undefined;
     const reifier = this._reifier || this._factory.blankNode();
     this._reifier = null;
-    this._tripleTerm = this._tripleTerm || this._factory.quad(this._subject, this._predicate, this._object);
+    this._tripleTerm = this._tripleTerm || this._createQuad(this._subject, this._predicate, this._object, null, this._inversePredicate);
     this._emit(reifier, this.RDF_REIFIES, this._tripleTerm, parentGraph || this._graph || this.DEFAULTGRAPH);
     return reifier;
   }
@@ -1297,6 +1311,26 @@ class N3Parser {
     }
   }
 
+  // ### `_createQuad` creates a quad
+  _createQuad(subject, predicate, object, graph) {
+    return this._factory.quad(subject, predicate, object, graph || this.DEFAULTGRAPH);
+  }
+
+  // ### `_createQuadInDirection` creates a quad in the active predicate direction
+  _createQuadInDirection(subject, predicate, object, graph, inversePredicate) {
+    return inversePredicate ? this._factory.quad(object, predicate, subject, graph || this.DEFAULTGRAPH) : this._factory.quad(subject, predicate, object, graph || this.DEFAULTGRAPH);
+  }
+
+  // ### `_emitInDirection` sends a quad in the active predicate direction
+  _emitInDirection(subject, predicate, object, graph, inversePredicate) {
+    this._callback(null, this._createQuad(subject, predicate, object, graph, inversePredicate));
+  }
+
+  // ### `_emitCurrentInDirection` sends a quad in the current predicate direction
+  _emitCurrentInDirection(subject, predicate, object, graph) {
+    this._callback(null, this._createQuad(subject, predicate, object, graph, this._inversePredicate));
+  }
+
   // ### `_emit` sends a quad through the callback
   _emit(subject, predicate, object, graph) {
     this._callback(null, this._factory.quad(subject, predicate, object, graph || this.DEFAULTGRAPH));

package/lib/N3Store.js

@@ -249,13 +249,12 @@ class N3Store {
 
   // ### `_findInIndex` finds a set of quads in a three-layered index.
   // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.
-  // Any of these keys can be undefined, which is interpreted as a wildcard.
+  // A key and any keys after it can be null or undefined, which is interpreted as a wildcard.
   // `name0`, `name1`, and `name2` are the names of the keys at each level,
   // used when reconstructing the resulting quad
   // (for instance: _subject_, _predicate_, and _object_).
   // Finally, `graphId` will be the graph of the created quads.
   *_findInIndex(index0, key0, key1, key2, name0, name1, name2, graphId) {
-    let tmp, index1, index2;
     const entityKeys = this._entities;
     const graph = this._termFromId(entityKeys[graphId]);
     const parts = {
@@ -264,24 +263,32 @@ class N3Store {
       object: null
     };
 
-    // If a key is specified, use only that part of index 0.
-    if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];
-    for (const value0 in index0) {
-      if (index1 = index0[value0]) {
-        parts[name0] = this._termFromId(entityKeys[value0]);
-        // If a key is specified, use only that part of index 1.
-        if (key1) (tmp = index1, index1 = {})[key1] = tmp[key1];
-        for (const value1 in index1) {
-          if (index2 = index1[value1]) {
-            parts[name1] = this._termFromId(entityKeys[value1]);
-            // If a key is specified, use only that part of index 2, if it exists.
-            const values = key2 ? key2 in index2 ? [key2] : [] : Object.keys(index2);
-            // Create quads for all items found in index 2.
-            for (let l = 0; l < values.length; l++) {
-              parts[name2] = this._termFromId(entityKeys[values[l]]);
-              yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
-            }
-          }
+    // Exact matches avoid allocating key arrays or entering generic loops.
+    if (key2) {
+      const index1 = index0[key0];
+      const index2 = index1 && index1[key1];
+      if (!index2 || !(key2 in index2)) return;
+      parts[name0] = this._termFromId(entityKeys[key0]);
+      parts[name1] = this._termFromId(entityKeys[key1]);
+      parts[name2] = this._termFromId(entityKeys[key2]);
+      yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
+      return;
+    }
+    if (key0 && !(key0 in index0)) return;
+    // A null key list stops after visiting a bound key, avoiding a one-item array.
+    const keys0 = key0 ? null : Object.keys(index0);
+    for (let i0 = 0, value0 = key0 || keys0[0]; value0; value0 = keys0 && keys0[++i0]) {
+      const index1 = index0[value0];
+      parts[name0] = this._termFromId(entityKeys[value0]);
+      if (key1 && !(key1 in index1)) return;
+      const keys1 = key1 ? null : Object.keys(index1);
+      for (let i1 = 0, value1 = key1 || keys1[0]; value1; value1 = keys1 && keys1[++i1]) {
+        const index2 = index1[value1];
+        parts[name1] = this._termFromId(entityKeys[value1]);
+        const values = Object.keys(index2);
+        for (let l = 0; l < values.length; l++) {
+          parts[name2] = this._termFromId(entityKeys[values[l]]);
+          yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
         }
       }
     }

package/package.json

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

package/src/N3Lexer.js

@@ -326,7 +326,7 @@ export default class N3Lexer {
       case 'h':
       case 'o':
         // Try to find an N3 verb keyword
-        if (this._n3Mode && (match = this._n3Verb.exec(input)))
+        if (this._n3Mode && (match = this._matchN3Verb(input, inputFinished)))
           type = match[0];
         else
           inconclusive = true;
@@ -336,7 +336,7 @@ export default class N3Lexer {
         // Try to find an IRI property list identifier or N3 verb keyword
         if (this._n3Mode && (match = this._n3Id.exec(input)))
           type = 'id';
-        else if (this._n3Mode && (match = this._n3Verb.exec(input)))
+        else if (this._n3Mode && (match = this._matchN3Verb(input, inputFinished)))
           type = match[0];
         else
           inconclusive = true;
@@ -455,6 +455,33 @@ export default class N3Lexer {
     function reportSyntaxError(self) { callback(self._syntaxError(/^\S*/.exec(input)[0])); }
   }
 
+  // ### `_matchN3Verb` matches an N3 verb unless the input is a longer prefixed name
+  _matchN3Verb(input, inputFinished) {
+    const verb = this._n3Verb.exec(input);
+    if (!verb)
+      return null;
+
+    // Most verb boundaries cannot be part of a prefix, so keep the common path fast.
+    const next = input[verb[0].length];
+    if (next !== '-' && next !== '_' && (next < '0' || next > '9'))
+      return verb;
+
+    // A prefix can start with a verb and continue with characters that are also
+    // valid verb boundaries. Prefer the longer prefixed name when it is complete.
+    if (this._prefixed.exec(input) || this._prefixed.exec(`${input} `))
+      return null;
+
+    // If a stream chunk ends partway through such a prefix, wait for the colon
+    // instead of prematurely emitting the verb. Appending ": " lets the prefix
+    // grammar determine whether all input seen so far can be a complete prefix.
+    if (!inputFinished) {
+      const prefix = this._prefix.exec(`${input}: `);
+      if (prefix)
+        return null;
+    }
+    return verb;
+  }
+
   // ### `_unescape` replaces N3 escape codes by their corresponding characters,
   // allowing only the fixed escape sequences from the given replacement table
   _unescape(item, replacements) {

package/src/N3Parser.js

@@ -23,6 +23,13 @@ export default class N3Parser {
         isNTriples = /triple/.test(format), isNQuads = /quad/.test(format),
         isN3 = this._n3Mode = /n3/.test(format),
         isLineMode = isNTriples || isNQuads;
+    // Keep inverse handling off the non-N3 emission path
+    this._emitCurrent = this._emit;
+    if (isN3) {
+      this._createQuad = this._createQuadInDirection;
+      this._emit = this._emitInDirection;
+      this._emitCurrent = this._emitCurrentInDirection;
+    }
     if (!(this._supportsNamedGraphs = !(isTurtle || isN3)))
       this._readPredicateOrNamedGraph = this._readPredicate;
     // Support triples in other graphs
@@ -550,7 +557,7 @@ export default class N3Parser {
 
     // Store blank node quad
     if (this._subject !== null)
-      this._emit(this._subject, this._predicate, this._object, this._graph);
+      this._emitCurrent(this._subject, this._predicate, this._object, this._graph);
 
     // Restore the parent context containing this blank node
     const empty = this._predicate === null;
@@ -911,7 +918,7 @@ export default class N3Parser {
 
     // Store the last quad of the formula
     if (this._subject !== null)
-      this._emit(this._subject, this._predicate, this._object, this._graph);
+      this._emitCurrent(this._subject, this._predicate, this._object, this._graph);
 
     const formula = this._graph, empty = this._emptyFormula;
     // Restore the parent context containing this formula
@@ -958,6 +965,7 @@ export default class N3Parser {
       break;
     // Semicolon means the subject is shared; predicate and object are different
     case ';':
+      if (inversePredicate) this._inversePredicate = false;
       next = this._readPredicate;
       break;
     // Comma means both the subject and predicate are shared; the object is different
@@ -980,6 +988,7 @@ export default class N3Parser {
       if (subject !== null)
         this._tripleTerm = null;
       this._subject = this._readTripleTerm();
+      this._inversePredicate = false;
       this._validAnnotation = false;
       startingAnnotation = true;
       next = this._readPredicate;
@@ -992,6 +1001,7 @@ export default class N3Parser {
         return this._error('Annotation block can not be empty', token);
       this._subject = null;
       this._annotation = false;
+      this._inversePredicate = false;
       next = this._getContextEndReader();
       break;
     default:
@@ -1005,10 +1015,7 @@ export default class N3Parser {
     // A quad has been completed now, so return it
     if (subject !== null && (!startingAnnotation || (startingAnnotation && !this._annotation))) {
       const predicate = this._predicate, object = this._object;
-      if (!inversePredicate)
-        this._emit(subject, predicate, object,  graph);
-      else
-        this._emit(object,  predicate, subject, graph);
+      this._emit(subject, predicate, object, graph, inversePredicate);
     }
     if (startingAnnotation) {
       this._annotation = true;
@@ -1018,10 +1025,11 @@ export default class N3Parser {
 
     // ### `_readBlankNodePunctuation` reads punctuation in a blank node
   _readBlankNodePunctuation(token) {
-    let next;
+    let next, resetInversePredicate = false;
     switch (token.type) {
     // Semicolon means the subject is shared; predicate and object are different
     case ';':
+      resetInversePredicate = this._inversePredicate;
       next = this._readPredicate;
       break;
     // Comma means both the subject and predicate are shared; the object is different
@@ -1044,7 +1052,9 @@ export default class N3Parser {
     if (this._subject === null)
       return this._error('Expected ] to follow annotation', token);
     // A quad has been completed now, so return it
-    this._emit(this._subject, this._predicate, this._object, this._graph);
+    this._emitCurrent(this._subject, this._predicate, this._object, this._graph);
+    if (resetInversePredicate)
+      this._inversePredicate = false;
     return next;
   }
 
@@ -1269,8 +1279,8 @@ export default class N3Parser {
     if (token.type !== ')>>')
       return this._error(`Expected )>> but got ${token.type}`, token);
     // Read the quad and restore the previous context
-    const quad = this._factory.quad(this._subject, this._predicate, this._object,
-        this._graph || this.DEFAULTGRAPH);
+    const quad = this._createQuad(this._subject, this._predicate, this._object,
+        this._graph, this._inversePredicate);
     this._restoreContext('<<(', token);
 
     // If we're in a list, continue processing that list
@@ -1371,6 +1381,7 @@ export default class N3Parser {
     switch (token.type) {
     // The subject stays shared with the next predicate-object pair
     case ';':
+      this._inversePredicate = false;
       return this._readPredicate;
     // The subject and predicate stay shared with the next object
     case ',':
@@ -1388,7 +1399,9 @@ export default class N3Parser {
     const parentGraph = parent ? parent.graph : undefined;
     const reifier = this._reifier || this._factory.blankNode();
     this._reifier = null;
-    this._tripleTerm = this._tripleTerm || this._factory.quad(this._subject, this._predicate, this._object);
+    this._tripleTerm = this._tripleTerm || this._createQuad(
+      this._subject, this._predicate, this._object, null, this._inversePredicate,
+    );
     this._emit(reifier, this.RDF_REIFIES, this._tripleTerm, parentGraph || this._graph || this.DEFAULTGRAPH);
     return reifier;
   }
@@ -1413,6 +1426,28 @@ export default class N3Parser {
     }
   }
 
+  // ### `_createQuad` creates a quad
+  _createQuad(subject, predicate, object, graph) {
+    return this._factory.quad(subject, predicate, object, graph || this.DEFAULTGRAPH);
+  }
+
+  // ### `_createQuadInDirection` creates a quad in the active predicate direction
+  _createQuadInDirection(subject, predicate, object, graph, inversePredicate) {
+    return inversePredicate ?
+      this._factory.quad(object, predicate, subject, graph || this.DEFAULTGRAPH) :
+      this._factory.quad(subject, predicate, object, graph || this.DEFAULTGRAPH);
+  }
+
+  // ### `_emitInDirection` sends a quad in the active predicate direction
+  _emitInDirection(subject, predicate, object, graph, inversePredicate) {
+    this._callback(null, this._createQuad(subject, predicate, object, graph, inversePredicate));
+  }
+
+  // ### `_emitCurrentInDirection` sends a quad in the current predicate direction
+  _emitCurrentInDirection(subject, predicate, object, graph) {
+    this._callback(null, this._createQuad(subject, predicate, object, graph, this._inversePredicate));
+  }
+
   // ### `_emit` sends a quad through the callback
   _emit(subject, predicate, object, graph) {
     this._callback(null, this._factory.quad(subject, predicate, object, graph || this.DEFAULTGRAPH));

package/src/N3Store.js

@@ -268,35 +268,49 @@ export default class N3Store {
 
   // ### `_findInIndex` finds a set of quads in a three-layered index.
   // The index base is `index0` and the keys at each level are `key0`, `key1`, and `key2`.
-  // Any of these keys can be undefined, which is interpreted as a wildcard.
+  // A key and any keys after it can be null or undefined, which is interpreted as a wildcard.
   // `name0`, `name1`, and `name2` are the names of the keys at each level,
   // used when reconstructing the resulting quad
   // (for instance: _subject_, _predicate_, and _object_).
   // Finally, `graphId` will be the graph of the created quads.
   *_findInIndex(index0, key0, key1, key2, name0, name1, name2, graphId) {
-    let tmp, index1, index2;
     const entityKeys = this._entities;
     const graph = this._termFromId(entityKeys[graphId]);
     const parts = { subject: null, predicate: null, object: null };
 
-    // If a key is specified, use only that part of index 0.
-    if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];
-    for (const value0 in index0) {
-      if (index1 = index0[value0]) {
-        parts[name0] = this._termFromId(entityKeys[value0]);
-        // If a key is specified, use only that part of index 1.
-        if (key1) (tmp = index1, index1 = {})[key1] = tmp[key1];
-        for (const value1 in index1) {
-          if (index2 = index1[value1]) {
-            parts[name1] = this._termFromId(entityKeys[value1]);
-            // If a key is specified, use only that part of index 2, if it exists.
-            const values = key2 ? (key2 in index2 ? [key2] : []) : Object.keys(index2);
-            // Create quads for all items found in index 2.
-            for (let l = 0; l < values.length; l++) {
-              parts[name2] = this._termFromId(entityKeys[values[l]]);
-              yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
-            }
-          }
+    // Exact matches avoid allocating key arrays or entering generic loops.
+    if (key2) {
+      const index1 = index0[key0];
+      const index2 = index1 && index1[key1];
+      if (!index2 || !(key2 in index2))
+        return;
+      parts[name0] = this._termFromId(entityKeys[key0]);
+      parts[name1] = this._termFromId(entityKeys[key1]);
+      parts[name2] = this._termFromId(entityKeys[key2]);
+      yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
+      return;
+    }
+
+    if (key0 && !(key0 in index0))
+      return;
+    // A null key list stops after visiting a bound key, avoiding a one-item array.
+    const keys0 = key0 ? null : Object.keys(index0);
+    for (let i0 = 0, value0 = key0 || keys0[0]; value0;
+         value0 = keys0 && keys0[++i0]) {
+      const index1 = index0[value0];
+      parts[name0] = this._termFromId(entityKeys[value0]);
+
+      if (key1 && !(key1 in index1))
+        return;
+      const keys1 = key1 ? null : Object.keys(index1);
+      for (let i1 = 0, value1 = key1 || keys1[0]; value1;
+           value1 = keys1 && keys1[++i1]) {
+        const index2 = index1[value1];
+        parts[name1] = this._termFromId(entityKeys[value1]);
+        const values = Object.keys(index2);
+        for (let l = 0; l < values.length; l++) {
+          parts[name2] = this._termFromId(entityKeys[values[l]]);
+          yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
         }
       }
     }