n3 2.2.1 → 2.2.3

package/lib/N3Parser.js

@@ -689,12 +689,17 @@ class N3Parser {
         break;
       // ~ is allowed in the annotation syntax
       case '~':
+        // Only invalidate the cache for a genuinely new triple - chained annotation blocks on the
+        // same triple (subject already null from a preceding annotation) must keep reusing it.
+        if (subject !== null) this._tripleTerm = null;
         next = this._readReifierInAnnotation;
         startingAnnotation = true;
         break;
       // {| means that the current triple is annotated with predicate-object pairs.
       case '{|':
         // Continue using the last triple as reified triple subject for the predicate-object pairs.
+        // Same staleness rule as ~ above.
+        if (subject !== null) this._tripleTerm = null;
         this._subject = this._readTripleTerm();
         this._validAnnotation = false;
         startingAnnotation = true;
@@ -1006,12 +1011,40 @@ class N3Parser {
     // If next token is a reifier, read it as such.
     if (token.type === 'IRI' || token.type === 'typeIRI' || token.type === 'type' || token.type === 'prefixed' || token.type === 'blank' || token.type === 'var') {
       this._reifier = this._readEntity(token);
-      return this._readPunctuation;
+      return this._readAnnotationBlockOrPunctuation;
     }
     // Otherwise, emit and assert triple term.
     this._readTripleTerm();
     this._subject = null;
-    return this._readPunctuation(token);
+    return this._getContextEndReader().call(this, token);
+  }
+
+  // ### `_readAnnotationBlockOrPunctuation` reads what follows an explicit reifier:
+  // either an annotation block, which reuses the reifier as its subject,
+  // or punctuation, in which case the reifier stands alone and its triple
+  // term still needs to be asserted here.
+  _readAnnotationBlockOrPunctuation(token) {
+    if (token.type === '{|') return this._readPunctuation(token);
+    this._readTripleTerm();
+    this._annotation = false;
+    // A shared subject or predicate goes on to reify a *different* triple,
+    // so the term just asserted must not be reused for the next one.
+    this._tripleTerm = null;
+    // The annotated triple was already emitted when the tilde was read,
+    // so continue without letting `_readPunctuation` emit it a second time.
+    switch (token.type) {
+      // The subject stays shared with the next predicate-object pair
+      case ';':
+        return this._readPredicate;
+      // The subject and predicate stay shared with the next object
+      case ',':
+        return this._readObject;
+      default:
+        this._subject = null;
+        // Resume in the enclosing context, which is top-level punctuation
+        // unless the reified triple sits inside a blank node property list
+        return this._getContextEndReader().call(this, token);
+    }
   }
   _readTripleTerm() {
     const stack = this._contextStack,

package/package.json

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

package/src/N3Parser.js

@@ -746,12 +746,19 @@ export default class N3Parser {
       break;
     // ~ is allowed in the annotation syntax
     case '~':
+      // Only invalidate the cache for a genuinely new triple - chained annotation blocks on the
+      // same triple (subject already null from a preceding annotation) must keep reusing it.
+      if (subject !== null)
+        this._tripleTerm = null;
       next = this._readReifierInAnnotation;
       startingAnnotation = true;
       break;
     // {| means that the current triple is annotated with predicate-object pairs.
     case '{|':
       // Continue using the last triple as reified triple subject for the predicate-object pairs.
+      // Same staleness rule as ~ above.
+      if (subject !== null)
+        this._tripleTerm = null;
       this._subject = this._readTripleTerm();
       this._validAnnotation = false;
       startingAnnotation = true;
@@ -1089,12 +1096,42 @@ export default class N3Parser {
     // If next token is a reifier, read it as such.
     if (token.type === 'IRI' || token.type === 'typeIRI' || token.type === 'type' || token.type === 'prefixed' || token.type === 'blank' || token.type === 'var') {
       this._reifier = this._readEntity(token);
-      return this._readPunctuation;
+      return this._readAnnotationBlockOrPunctuation;
     }
     // Otherwise, emit and assert triple term.
     this._readTripleTerm();
     this._subject = null;
-    return this._readPunctuation(token);
+    return this._getContextEndReader().call(this, token);
+  }
+
+  // ### `_readAnnotationBlockOrPunctuation` reads what follows an explicit reifier:
+  // either an annotation block, which reuses the reifier as its subject,
+  // or punctuation, in which case the reifier stands alone and its triple
+  // term still needs to be asserted here.
+  _readAnnotationBlockOrPunctuation(token) {
+    if (token.type === '{|')
+      return this._readPunctuation(token);
+
+    this._readTripleTerm();
+    this._annotation = false;
+    // A shared subject or predicate goes on to reify a *different* triple,
+    // so the term just asserted must not be reused for the next one.
+    this._tripleTerm = null;
+    // The annotated triple was already emitted when the tilde was read,
+    // so continue without letting `_readPunctuation` emit it a second time.
+    switch (token.type) {
+    // The subject stays shared with the next predicate-object pair
+    case ';':
+      return this._readPredicate;
+    // The subject and predicate stay shared with the next object
+    case ',':
+      return this._readObject;
+    default:
+      this._subject = null;
+      // Resume in the enclosing context, which is top-level punctuation
+      // unless the reified triple sits inside a blank node property list
+      return this._getContextEndReader().call(this, token);
+    }
   }
 
   _readTripleTerm() {