n3 2.2.2 → 2.2.4

package/lib/N3Parser.js

@@ -711,7 +711,7 @@ class N3Parser {
         if (!this._validAnnotation) return this._error('Annotation block can not be empty', token);
         this._subject = null;
         this._annotation = false;
-        next = this._readPunctuation;
+        next = this._getContextEndReader();
         break;
       default:
         // An entity means this is a quad (only allowed if not already inside a graph)
@@ -745,9 +745,20 @@ class N3Parser {
       case ',':
         next = this._readObject;
         break;
+      // Annotation syntax applies to the quad just read, exactly as it does
+      // outside of a blank node property list.  `|}` arrives here too, because
+      // the objects inside the annotation block are themselves read within the
+      // enclosing blank node context.
+      case '~':
+      case '{|':
+      case '|}':
+        return this._readPunctuation(token);
       default:
         return this._error(`Expected punctuation to follow "${this._object.id}"`, token);
     }
+    // An annotation block consumes the subject it annotates, so there is
+    // 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);
     return next;
@@ -1011,12 +1022,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.2",
+  "version": "2.2.4",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [

package/src/N3Parser.js

@@ -772,7 +772,7 @@ export default class N3Parser {
         return this._error('Annotation block can not be empty', token);
       this._subject = null;
       this._annotation = false;
-      next = this._readPunctuation;
+      next = this._getContextEndReader();
       break;
     default:
       // An entity means this is a quad (only allowed if not already inside a graph)
@@ -808,9 +808,21 @@ export default class N3Parser {
     case ',':
       next = this._readObject;
       break;
+    // Annotation syntax applies to the quad just read, exactly as it does
+    // outside of a blank node property list.  `|}` arrives here too, because
+    // the objects inside the annotation block are themselves read within the
+    // enclosing blank node context.
+    case '~':
+    case '{|':
+    case '|}':
+      return this._readPunctuation(token);
     default:
       return this._error(`Expected punctuation to follow "${this._object.id}"`, token);
     }
+    // An annotation block consumes the subject it annotates, so there is
+    // 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);
     return next;
@@ -1096,12 +1108,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() {