n3 2.7.12 → 2.9.0

package/lib/N3Parser.js

@@ -1446,14 +1446,16 @@ class N3Parser {
 
   // ### `parse` parses the N3 input and emits each parsed quad through the onQuad callback.
   parse(input, quadCallback, prefixCallback, versionCallback) {
-    // The second parameter accepts an object { onQuad: ..., onPrefix: ..., onComment: ...}
+    // The second parameter also accepts an object of named callbacks.
     // As a second and third parameter it still accepts a separate quadCallback and prefixCallback for backward compatibility as well
-    let onQuad, onPrefix, onComment, onVersion;
-    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion)) {
+    let onQuad, onPrefix, onComment, onVersion, onToken, onTokenEnd;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion || quadCallback.onToken || quadCallback.onTokenEnd)) {
       onQuad = quadCallback.onQuad;
       onPrefix = quadCallback.onPrefix;
       onComment = quadCallback.onComment;
       onVersion = quadCallback.onVersion;
+      onToken = quadCallback.onToken;
+      onTokenEnd = quadCallback.onTokenEnd;
     } else {
       onQuad = quadCallback;
       onPrefix = prefixCallback;
@@ -1473,36 +1475,55 @@ class N3Parser {
     this._expectOf = false;
     this._quantified = Object.create(null);
     this._emptyFormula = false;
+    let readToken = token => {
+      return this._readCallback = this._readCallback(token);
+    };
+
+    // Comments bypass the grammar, but participate in the token lifecycle.
+    if (onComment || this._lexer.comments) {
+      this._lexer.comments = true;
+      const readGrammarToken = readToken;
+      readToken = token => {
+        if (token.type !== 'comment') return readGrammarToken(token);
+        if (onComment) onComment(token.value);
+        return this._readCallback;
+      };
+    }
+
+    // Install observers once per parse, leaving the ordinary token path intact.
+    if (onToken || onTokenEnd) {
+      const consumeToken = readToken;
+      readToken = token => {
+        try {
+          try {
+            if (onToken) onToken(token);
+            return consumeToken(token);
+          } finally {
+            if (onTokenEnd) onTokenEnd(token);
+          }
+        } catch (error) {
+          // A consumer exception aborts this parse, including later chunks.
+          this._readCallback = null;
+          throw error;
+        }
+      };
+    }
 
-    // Parse synchronously if no quad callback is given
+    // Parse synchronously if no quad callback is given.
     if (!onQuad) {
       const quads = [];
       let error;
       this._callback = (e, t) => {
         e ? error = e : t && quads.push(t);
       };
-      this._lexer.tokenize(input).every(token => {
-        return this._readCallback = this._readCallback(token);
-      });
+      this._lexer.tokenize(input).every(readToken);
       if (error) throw error;
       return quads;
     }
-    let processNextToken = (error, token) => {
-      if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) this._readCallback = this._readCallback(token);
+    const processNextToken = (error, token) => {
+      if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) readToken(token);
     };
 
-    // Enable checking for comments on every token when a commentCallback has been set
-    if (onComment) {
-      // Enable the lexer to return comments as tokens first (disabled by default)
-      this._lexer.comments = true;
-      // Patch the processNextToken function
-      processNextToken = (error, token) => {
-        if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) {
-          if (token.type === 'comment') onComment(token.value);else this._readCallback = this._readCallback(token);
-        }
-      };
-    }
-
     // Parse asynchronously otherwise, executing the read callback when a token arrives
     this._callback = onQuad;
     this._lexer.tokenize(input, processNextToken);

package/lib/N3Reasoner.js

@@ -34,10 +34,17 @@ class N3Reasoner {
     this._maxPremiseDepth = options.maxPremiseDepth === undefined ? Infinity : options.maxPremiseDepth;
   }
   _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);
-    this._store._addToIndex(graphItem.objects, object, subject, predicate);
+    const store = this._store;
+    // Observing views must see each derivation before indexing
+    // (stores from other N3 versions have no observers)
+    if (store._observers) {
+      if (!store._addQuad(subject, predicate, object, this._graphId)) return;
+    } else {
+      // Only add to the remaining indexes if there is not already a value in the index
+      if (!store._addToIndex(graphItem.subjects, subject, predicate, object)) return;
+      store._addToIndex(graphItem.predicates, predicate, object, subject);
+      store._addToIndex(graphItem.objects, object, subject, predicate);
+    }
     // Count genuinely new derivations and fail past the budget. The check comes
     // after all three indexes are updated, so a caught error leaves the store
     // in a consistent state (the reasoning result is merely incomplete).
@@ -224,6 +231,8 @@ class N3Reasoner {
     const graphs = this._store._getGraphs();
     try {
       for (const graphId in graphs) {
+        // Observers compare numeric graph identifiers
+        this._graphId = Number(graphId);
         this._reasonGraphNaive(rules, graphs[graphId]);
       }
     } finally {