n3 1.20.4 → 1.21.1

package/lib/N3Lexer.js

@@ -97,7 +97,7 @@ class N3Lexer {
       this._n3Mode = options.n3 !== false;
     }
     // Don't output comment tokens by default
-    this._comments = !!options.comments;
+    this.comments = !!options.comments;
     // Cache the last tested closing position of long literals
     this._literalClosingPos = 0;
   }
@@ -114,7 +114,7 @@ class N3Lexer {
       let whiteSpaceMatch, comment;
       while (whiteSpaceMatch = this._newline.exec(input)) {
         // Try to find a comment
-        if (this._comments && (comment = this._comment.exec(whiteSpaceMatch[0]))) emitToken('comment', comment[1], '', this._line, whiteSpaceMatch[0].length);
+        if (this.comments && (comment = this._comment.exec(whiteSpaceMatch[0]))) emitToken('comment', comment[1], '', this._line, whiteSpaceMatch[0].length);
         // Advance the input
         input = input.substr(whiteSpaceMatch[0].length, input.length);
         currentLineLength = input.length;
@@ -128,7 +128,7 @@ class N3Lexer {
         // If the input is finished, emit EOF
         if (inputFinished) {
           // Try to find a final comment
-          if (this._comments && (comment = this._comment.exec(input))) emitToken('comment', comment[1], '', this._line, input.length);
+          if (this.comments && (comment = this._comment.exec(input))) emitToken('comment', comment[1], '', this._line, input.length);
           input = null;
           emitToken('eof', '', '', this._line, 0);
         }

package/lib/N3Parser.js

@@ -943,20 +943,31 @@ class N3Parser {
 
   // ## Public methods
 
-  // ### `parse` parses the N3 input and emits each parsed quad through the callback
+  // ### `parse` parses the N3 input and emits each parsed quad through the onQuad callback.
   parse(input, quadCallback, prefixCallback) {
+    // The second parameter accepts an object { onQuad: ..., onPrefix: ..., onComment: ...}
+    // As a second and third parameter it still accepts a separate quadCallback and prefixCallback for backward compatibility as well
+    let onQuad, onPrefix, onComment;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment)) {
+      onQuad = quadCallback.onQuad;
+      onPrefix = quadCallback.onPrefix;
+      onComment = quadCallback.onComment;
+    } else {
+      onQuad = quadCallback;
+      onPrefix = prefixCallback;
+    }
     // The read callback is the next function to be executed when a token arrives.
     // We start reading in the top context.
     this._readCallback = this._readInTopContext;
     this._sparqlStyle = false;
     this._prefixes = Object.create(null);
     this._prefixes._ = this._blankNodePrefix ? this._blankNodePrefix.substr(2) : `b${blankNodePrefix++}_`;
-    this._prefixCallback = prefixCallback || noop;
+    this._prefixCallback = onPrefix || noop;
     this._inversePredicate = false;
     this._quantified = Object.create(null);
 
     // Parse synchronously if no quad callback is given
-    if (!quadCallback) {
+    if (!onQuad) {
       const quads = [];
       let error;
       this._callback = (e, t) => {
@@ -968,12 +979,25 @@ class N3Parser {
       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);
+    };
+
+    // 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 = quadCallback;
-    this._lexer.tokenize(input, (error, token) => {
-      if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) this._readCallback = this._readCallback(token);
-    });
+    this._callback = onQuad;
+    this._lexer.tokenize(input, processNextToken);
   }
 }
 

package/lib/N3Store.js

@@ -21,6 +21,32 @@ function merge(target, source, depth = 4) {
   return target;
 }
 
+/**
+ * Determines the intersection of the `_graphs` index s1 and s2.
+ * s1 and s2 *must* belong to Stores that share an `_entityIndex`.
+ *
+ * False is returned when there is no intersection; this should
+ * *not* be set as the value for an index.
+ */
+function intersect(s1, s2, depth = 4) {
+  let target = false;
+  for (const key in s1) {
+    if (key in s2) {
+      const intersection = depth === 0 ? null : intersect(s1[key], s2[key], depth - 1);
+      if (intersection !== false) {
+        target = target || Object.create(null);
+        target[key] = intersection;
+      }
+      // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
+      // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
+      else if (depth === 3) {
+        return false;
+      }
+    }
+  }
+  return target;
+}
+
 // ## Constructor
 class N3EntityIndex {
   constructor(options = {}) {
@@ -350,7 +376,12 @@ class N3Store {
   // ### `removeQuad` removes a quad from the store if it exists
   removeQuad(subject, predicate, object, graph) {
     // Shift arguments if a quad object is given instead of components
-    if (!predicate) graph = subject.graph, object = subject.object, predicate = subject.predicate, subject = subject.subject;
+    if (!predicate) ({
+      subject,
+      predicate,
+      object,
+      graph
+    } = subject);
     // Convert terms to internal string representation
     graph = graph ? this._termToNumericId(graph) : 1;
 
@@ -846,6 +877,17 @@ class N3Store {
       });
       store._graphs = merge(Object.create(null), this._graphs);
       store._size = this._size;
+      return store;
+    } else if (other instanceof N3Store && this._entityIndex === other._entityIndex) {
+      const store = new N3Store({
+        entityIndex: this._entityIndex
+      });
+      const graphs = intersect(other._graphs, this._graphs);
+      if (graphs) {
+        store._graphs = graphs;
+        store._size = null;
+      }
+      return store;
     }
     return this.filter(quad => other.has(quad));
   }

package/lib/N3StreamParser.js

@@ -20,6 +20,19 @@ class N3StreamParser extends _readableStream.Transform {
     // Set up parser with dummy stream to obtain `data` and `end` callbacks
     const parser = new _N3Parser.default(options);
     let onData, onEnd;
+    const callbacks = {
+      // Handle quads by pushing them down the pipeline
+      onQuad: (error, quad) => {
+        error && this.emit('error', error) || quad && this.push(quad);
+      },
+      // Emit prefixes through the `prefix` event
+      onPrefix: (prefix, uri) => {
+        this.emit('prefix', prefix, uri);
+      }
+    };
+    if (options && options.comments) callbacks.onComment = comment => {
+      this.emit('comment', comment);
+    };
     parser.parse({
       on: (event, callback) => {
         switch (event) {
@@ -31,15 +44,7 @@ class N3StreamParser extends _readableStream.Transform {
             break;
         }
       }
-    },
-    // Handle quads by pushing them down the pipeline
-    (error, quad) => {
-      error && this.emit('error', error) || quad && this.push(quad);
-    },
-    // Emit prefixes through the `prefix` event
-    (prefix, uri) => {
-      this.emit('prefix', prefix, uri);
-    });
+    }, callbacks);
 
     // Implement Transform methods through parser callbacks
     this._transform = (chunk, encoding, done) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "1.20.4",
+  "version": "1.21.1",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [
@@ -34,9 +34,9 @@
     "@babel/preset-env": "^7.16.0",
     "@babel/register": "^7.16.0",
     "@rdfjs/data-model": "^1",
-    "arrayify-stream": "^1.0.0",
+    "arrayify-stream": "^3.0.0",
     "browserify": "^17.0.0",
-    "deep-taxonomy-benchmark": "^1.2.0",
+    "deep-taxonomy-benchmark": "^2.0.0",
     "docco": "^0.9.1",
     "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.29.1",

package/src/N3Lexer.js

@@ -68,7 +68,7 @@ export default class N3Lexer {
       this._n3Mode = options.n3 !== false;
     }
     // Don't output comment tokens by default
-    this._comments = !!options.comments;
+    this.comments = !!options.comments;
     // Cache the last tested closing position of long literals
     this._literalClosingPos = 0;
   }
@@ -85,7 +85,7 @@ export default class N3Lexer {
       let whiteSpaceMatch, comment;
       while (whiteSpaceMatch = this._newline.exec(input)) {
         // Try to find a comment
-        if (this._comments && (comment = this._comment.exec(whiteSpaceMatch[0])))
+        if (this.comments && (comment = this._comment.exec(whiteSpaceMatch[0])))
           emitToken('comment', comment[1], '', this._line, whiteSpaceMatch[0].length);
         // Advance the input
         input = input.substr(whiteSpaceMatch[0].length, input.length);
@@ -101,7 +101,7 @@ export default class N3Lexer {
         // If the input is finished, emit EOF
         if (inputFinished) {
           // Try to find a final comment
-          if (this._comments && (comment = this._comment.exec(input)))
+          if (this.comments && (comment = this._comment.exec(input)))
             emitToken('comment', comment[1], '', this._line, input.length);
           input = null;
           emitToken('eof', '', '', this._line, 0);

package/src/N3Parser.js

@@ -1010,8 +1010,20 @@ export default class N3Parser {
 
   // ## Public methods
 
-  // ### `parse` parses the N3 input and emits each parsed quad through the callback
+  // ### `parse` parses the N3 input and emits each parsed quad through the onQuad callback.
   parse(input, quadCallback, prefixCallback) {
+    // The second parameter accepts an object { onQuad: ..., onPrefix: ..., onComment: ...}
+    // As a second and third parameter it still accepts a separate quadCallback and prefixCallback for backward compatibility as well
+    let onQuad, onPrefix, onComment;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment)) {
+      onQuad = quadCallback.onQuad;
+      onPrefix = quadCallback.onPrefix;
+      onComment = quadCallback.onComment;
+    }
+    else {
+      onQuad = quadCallback;
+      onPrefix = prefixCallback;
+    }
     // The read callback is the next function to be executed when a token arrives.
     // We start reading in the top context.
     this._readCallback = this._readInTopContext;
@@ -1019,12 +1031,12 @@ export default class N3Parser {
     this._prefixes = Object.create(null);
     this._prefixes._ = this._blankNodePrefix ? this._blankNodePrefix.substr(2)
                                              : `b${blankNodePrefix++}_`;
-    this._prefixCallback = prefixCallback || noop;
+    this._prefixCallback = onPrefix || noop;
     this._inversePredicate = false;
     this._quantified = Object.create(null);
 
     // Parse synchronously if no quad callback is given
-    if (!quadCallback) {
+    if (!onQuad) {
       const quads = [];
       let error;
       this._callback = (e, t) => { e ? (error = e) : t && quads.push(t); };
@@ -1035,14 +1047,33 @@ export default class N3Parser {
       return quads;
     }
 
-    // Parse asynchronously otherwise, executing the read callback when a token arrives
-    this._callback = quadCallback;
-    this._lexer.tokenize(input, (error, token) => {
+    let processNextToken = (error, token) => {
       if (error !== null)
         this._callback(error), this._callback = noop;
       else if (this._readCallback)
         this._readCallback = this._readCallback(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/src/N3Store.js

@@ -17,6 +17,34 @@ function merge(target, source, depth = 4) {
   return target;
 }
 
+/**
+ * Determines the intersection of the `_graphs` index s1 and s2.
+ * s1 and s2 *must* belong to Stores that share an `_entityIndex`.
+ *
+ * False is returned when there is no intersection; this should
+ * *not* be set as the value for an index.
+ */
+function intersect(s1, s2, depth = 4) {
+  let target = false;
+
+  for (const key in s1) {
+    if (key in s2) {
+      const intersection = depth === 0 ? null : intersect(s1[key], s2[key], depth - 1);
+      if (intersection !== false) {
+        target = target || Object.create(null);
+        target[key] = intersection;
+      }
+      // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
+      // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
+      else if (depth === 3) {
+        return false;
+      }
+    }
+  }
+
+  return target;
+}
+
 // ## Constructor
 export class N3EntityIndex {
   constructor(options = {}) {
@@ -356,8 +384,7 @@ export default class N3Store {
   removeQuad(subject, predicate, object, graph) {
     // Shift arguments if a quad object is given instead of components
     if (!predicate)
-      graph = subject.graph, object = subject.object,
-        predicate = subject.predicate, subject = subject.subject;
+      ({ subject, predicate, object, graph } = subject);
     // Convert terms to internal string representation
     graph = graph ? this._termToNumericId(graph) : 1;
 
@@ -902,7 +929,18 @@ export default class N3Store {
       const store = new N3Store({ entityIndex: this._entityIndex });
       store._graphs = merge(Object.create(null), this._graphs);
       store._size = this._size;
+      return store;
     }
+    else if ((other instanceof N3Store) && this._entityIndex === other._entityIndex) {
+      const store = new N3Store({ entityIndex: this._entityIndex });
+      const graphs = intersect(other._graphs, this._graphs);
+      if (graphs) {
+        store._graphs = graphs;
+        store._size = null;
+      }
+      return store;
+    }
+
     return this.filter(quad => other.has(quad));
   }
 

package/src/N3StreamParser.js

@@ -11,6 +11,17 @@ export default class N3StreamParser extends Transform {
     // Set up parser with dummy stream to obtain `data` and `end` callbacks
     const parser = new N3Parser(options);
     let onData, onEnd;
+
+    const callbacks = {
+        // Handle quads by pushing them down the pipeline
+      onQuad: (error, quad) => { error && this.emit('error', error) || quad && this.push(quad); },
+        // Emit prefixes through the `prefix` event
+      onPrefix: (prefix, uri) => { this.emit('prefix', prefix, uri); },
+    };
+
+    if (options && options.comments)
+      callbacks.onComment = comment => { this.emit('comment', comment); };
+
     parser.parse({
       on: (event, callback) => {
         switch (event) {
@@ -18,12 +29,7 @@ export default class N3StreamParser extends Transform {
         case 'end':   onEnd = callback; break;
         }
       },
-    },
-      // Handle quads by pushing them down the pipeline
-      (error, quad) => { error && this.emit('error', error) || quad && this.push(quad); },
-      // Emit prefixes through the `prefix` event
-      (prefix, uri) => { this.emit('prefix', prefix, uri); },
-    );
+    }, callbacks);
 
     // Implement Transform methods through parser callbacks
     this._transform = (chunk, encoding, done) => { onData(chunk); done(); };