n3 1.20.3 → 1.21.0

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

@@ -15,6 +15,11 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 // **N3Store** objects store N3 quads by graph in memory.
 
 const ITERATOR = Symbol('iter');
+function merge(target, source, depth = 4) {
+  if (depth === 0) return Object.assign(target, source);
+  for (const key in source) target[key] = merge(target[key] || Object.create(null), source[key], depth - 1);
+  return target;
+}
 
 // ## Constructor
 class N3EntityIndex {
@@ -125,7 +130,7 @@ class N3Store {
     const index1 = index0[key0] || (index0[key0] = {});
     const index2 = index1[key1] || (index1[key1] = {});
     // Setting the key to _any_ value signals the presence of the quad
-    const existed = (key2 in index2);
+    const existed = key2 in index2;
     if (!existed) index2[key2] = null;
     return !existed;
   }
@@ -345,7 +350,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;
 
@@ -746,7 +756,12 @@ class N3Store {
    * Blank Nodes will be normalized.
    */
   addAll(quads) {
-    if (Array.isArray(quads)) this.addQuads(quads);else {
+    if (Array.isArray(quads)) this.addQuads(quads);else if (quads instanceof N3Store && quads._entityIndex === this._entityIndex) {
+      if (quads._size !== 0) {
+        this._graphs = merge(this._graphs, quads._graphs);
+        this._size = null; // Invalidate the cached size
+      }
+    } else {
       for (const quad of quads) this.add(quad);
     }
     return this;
@@ -759,6 +774,7 @@ class N3Store {
    * Blank Nodes will be normalized.
    */
   contains(other) {
+    if (other === this) return true;
     if (!(other instanceof N3Store) || this._entityIndex !== other._entityIndex) return other.every(quad => this.has(quad));
     const g1 = this._graphs,
       g2 = other._graphs;
@@ -797,6 +813,9 @@ class N3Store {
    * Returns a new dataset that contains all quads from the current dataset that are not included in the given dataset.
    */
   difference(other) {
+    if (other === this) return new N3Store({
+      entityIndex: this._entityIndex
+    });
     return this.filter(quad => !other.has(quad));
   }
 
@@ -826,6 +845,13 @@ class N3Store {
    * Returns a new dataset containing all quads from the current dataset that are also included in the given dataset.
    */
   intersection(other) {
+    if (other === this) {
+      const store = new N3Store({
+        entityIndex: this._entityIndex
+      });
+      store._graphs = merge(Object.create(null), this._graphs);
+      store._size = this._size;
+    }
     return this.filter(quad => other.has(quad));
   }
 
@@ -898,7 +924,8 @@ class N3Store {
     const store = new N3Store({
       entityIndex: this._entityIndex
     });
-    store.addAll(this);
+    store._graphs = merge(Object.create(null), this._graphs);
+    store._size = this._size;
     store.addAll(quads);
     return store;
   }

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.3",
+  "version": "1.21.0",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [
@@ -36,10 +36,9 @@
     "@rdfjs/data-model": "^1",
     "arrayify-stream": "^1.0.0",
     "browserify": "^17.0.0",
-    "colors": "^1.1.2",
     "deep-taxonomy-benchmark": "^1.2.0",
     "docco": "^0.9.1",
-    "eslint": "^5.14.1",
+    "eslint": "^8.57.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
     "pre-commit": "^1.2.2",

package/src/N3DataFactory.js

@@ -229,7 +229,7 @@ export function termFromId(id, factory, nested) {
     termFromId(id[0], factory, true),
     termFromId(id[1], factory, true),
     termFromId(id[2], factory, true),
-    id[3] && termFromId(id[3], factory, true)
+    id[3] && termFromId(id[3], factory, true),
   );
 }
 

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

@@ -7,6 +7,16 @@ import N3Writer from './N3Writer';
 
 const ITERATOR = Symbol('iter');
 
+function merge(target, source, depth = 4) {
+  if (depth === 0)
+    return Object.assign(target, source);
+
+  for (const key in source)
+    target[key] = merge(target[key] || Object.create(null), source[key], depth - 1);
+
+  return target;
+}
+
 // ## Constructor
 export class N3EntityIndex {
   constructor(options = {}) {
@@ -31,7 +41,7 @@ export class N3EntityIndex {
         this._termFromId(entities[terms[1]]),
         this._termFromId(entities[terms[2]]),
         this._termFromId(entities[terms[3]]),
-        terms[4] && this._termFromId(entities[terms[4]])
+        terms[4] && this._termFromId(entities[terms[4]]),
       );
       return q;
     }
@@ -346,8 +356,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;
 
@@ -792,6 +801,12 @@ export default class N3Store {
   addAll(quads) {
     if (Array.isArray(quads))
       this.addQuads(quads);
+    else if (quads instanceof N3Store && quads._entityIndex === this._entityIndex) {
+      if (quads._size !== 0) {
+        this._graphs = merge(this._graphs, quads._graphs);
+        this._size = null; // Invalidate the cached size
+      }
+    }
     else {
       for (const quad of quads)
         this.add(quad);
@@ -799,7 +814,6 @@ export default class N3Store {
     return this;
   }
 
-
   /**
    * Returns `true` if the current dataset is a superset of the given dataset; in other words, returns `true` if
    * the given dataset is a subset of, i.e., is contained within, the current dataset.
@@ -807,6 +821,9 @@ export default class N3Store {
    * Blank Nodes will be normalized.
    */
   contains(other) {
+    if (other === this)
+      return true;
+
     if (!(other instanceof N3Store) || this._entityIndex !== other._entityIndex)
       return other.every(quad => this.has(quad));
 
@@ -848,6 +865,9 @@ export default class N3Store {
    * Returns a new dataset that contains all quads from the current dataset that are not included in the given dataset.
    */
   difference(other) {
+    if (other === this)
+      return new N3Store({ entityIndex: this._entityIndex });
+
     return this.filter(quad => !other.has(quad));
   }
 
@@ -877,6 +897,11 @@ export default class N3Store {
    * Returns a new dataset containing all quads from the current dataset that are also included in the given dataset.
    */
   intersection(other) {
+    if (other === this) {
+      const store = new N3Store({ entityIndex: this._entityIndex });
+      store._graphs = merge(Object.create(null), this._graphs);
+      store._size = this._size;
+    }
     return this.filter(quad => other.has(quad));
   }
 
@@ -947,7 +972,9 @@ export default class N3Store {
    */
   union(quads) {
     const store = new N3Store({ entityIndex: this._entityIndex });
-    store.addAll(this);
+    store._graphs = merge(Object.create(null), this._graphs);
+    store._size = this._size;
+
     store.addAll(quads);
     return store;
   }

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(); };