n3 2.2.10 → 2.2.12

package/lib/N3Lexer.js

@@ -13,9 +13,10 @@ const {
   xsd
 } = _IRIs.default;
 
-// Regular expression and replacement string to escape N3 strings
+// Regular expression and replacement strings to unescape N3 strings
 const escapeSequence = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{8})|\\([^])/g;
-const escapeReplacements = {
+// Fixed escape sequences allowed in string literals (ECHAR)
+const stringEscapeReplacements = {
   '\\': '\\',
   "'": "'",
   '"': '"',
@@ -23,7 +24,10 @@ const escapeReplacements = {
   'r': '\r',
   't': '\t',
   'f': '\f',
-  'b': '\b',
+  'b': '\b'
+};
+// Fixed escape sequences allowed in local names of prefixed names (PN_LOCAL_ESC)
+const localNameEscapeReplacements = {
   '_': '_',
   '~': '~',
   '.': '.',
@@ -31,6 +35,7 @@ const escapeReplacements = {
   '!': '!',
   '$': '$',
   '&': '&',
+  "'": "'",
   '(': '(',
   ')': ')',
   '*': '*',
@@ -181,7 +186,7 @@ class N3Lexer {
           if (match = this._unescapedIri.exec(input)) type = 'IRI', value = match[1];
           // Try to find a full IRI with escape sequences
           else if (match = this._iri.exec(input)) {
-            value = this._unescape(match[1]);
+            value = this._unescape(match[1], stringEscapeReplacements);
             if (value === null || illegalIriChars.test(value)) return reportSyntaxError(this);
             type = 'IRI';
           }
@@ -364,7 +369,7 @@ class N3Lexer {
         // Try to find a prefixed name. Since it can contain (but not end with) a dot,
         // we always need a non-dot character before deciding it is a prefixed name.
         // Therefore, try inserting a space if we're at the end of the input.
-        else if ((match = this._prefixed.exec(input)) || inputFinished && (match = this._prefixed.exec(`${input} `))) type = 'prefixed', prefix = match[1] || '', value = this._unescape(match[2]);
+        else if ((match = this._prefixed.exec(input)) || inputFinished && (match = this._prefixed.exec(`${input} `))) type = 'prefixed', prefix = match[1] || '', value = this._unescape(match[2], localNameEscapeReplacements);
       }
 
       // A type token is special: it can only be emitted after an IRI or prefixed name is read
@@ -420,8 +425,9 @@ class N3Lexer {
     }
   }
 
-  // ### `_unescape` replaces N3 escape codes by their corresponding characters
-  _unescape(item) {
+  // ### `_unescape` replaces N3 escape codes by their corresponding characters,
+  // allowing only the fixed escape sequences from the given replacement table
+  _unescape(item, replacements) {
     let invalid = false;
     const replaced = item.replace(escapeSequence, (sequence, unicode4, unicode8, escapedChar) => {
       // 4-digit unicode character
@@ -443,7 +449,7 @@ class N3Lexer {
         return charCode <= 0xFFFF ? String.fromCharCode(Number.parseInt(unicode8, 16)) : String.fromCharCode(0xD800 + ((charCode -= 0x10000) >> 10), 0xDC00 + (charCode & 0x3FF));
       }
       // fixed escape sequence
-      if (escapedChar in escapeReplacements) return escapeReplacements[escapedChar];
+      if (escapedChar in replacements) return replacements[escapedChar];
       // invalid escape sequence
       invalid = true;
       return '';
@@ -477,7 +483,7 @@ class N3Lexer {
           if (openingLength === 1 && lines !== 0 || openingLength === 3 && this._lineMode) break;
           this._line += lines;
           return {
-            value: this._unescape(raw),
+            value: this._unescape(raw, stringEscapeReplacements),
             matchLength
           };
         }

package/lib/N3Parser.js

@@ -508,7 +508,23 @@ class N3Parser {
       case '{':
         // Start a new formula
         if (!this._n3Mode) return this._error('Unexpected graph', token);
-        this._saveContext('formula', this._graph, this._subject, this._predicate, this._graph = this._factory.blankNode());
+        // The formula is an item of the list,
+        // so it must be linked in the list's graph before the graph changes
+        list = this._factory.blankNode();
+        item = this._factory.blankNode();
+        // Is this the first element of the list?
+        if (previousList === null) {
+          // This list is either the subject or the object of its parent
+          if (parent.predicate === null) parent.subject = list;else parent.object = list;
+        } else {
+          // Continue the previous list with the current list
+          this._emit(previousList, this.RDF_REST, list, this._graph);
+        }
+        // Output the item
+        this._emit(list, this.RDF_FIRST, item, this._graph);
+        // Stack the current list quad and start the formula
+        this._saveContext('formula', this._graph, list, this.RDF_FIRST, this._graph = item);
+        this._subject = null;
         return this._readSubject;
       case '<<(':
         this._saveContext('<<(', this._graph, null, null, null);

package/lib/N3StreamWriter.js

@@ -9,6 +9,9 @@ var _N3Writer = _interopRequireDefault(require("./N3Writer"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // **N3StreamWriter** serializes a quad stream into a text stream.
 
+const MIN_CHUNK_SIZE = 16 * 1024;
+const DEFAULT_FLUSH_DELAY_MS = 20;
+
 // ## Constructor
 class N3StreamWriter extends _readableStream.Transform {
   constructor(options) {
@@ -17,27 +20,77 @@ class N3StreamWriter extends _readableStream.Transform {
       writableObjectMode: true
     });
 
+    // Coalesce serialized fragments into larger stream chunks
+    this._buffer = '';
+
+    // Flush partial chunks after a bounded delay
+    this._flushTimer = null;
+    this._flushDelay = options && options.flushDelay !== undefined ? options.flushDelay : DEFAULT_FLUSH_DELAY_MS;
+
     // Set up writer with a dummy stream object
     const writer = this._writer = new _N3Writer.default({
-      write: (quad, encoding, callback) => {
-        this.push(quad);
+      write: (chunk, encoding, callback) => {
+        this._buffer += chunk;
+        if (this._buffer.length >= MIN_CHUNK_SIZE) this._pushBuffer();else if (this._flushTimer === null) this._armFlushTimer();
         callback && callback();
       },
       end: callback => {
+        this._pushBuffer();
         this.push(null);
         callback && callback();
       }
     }, options);
 
-    // Implement Transform methods on top of writer
+    // Flush buffered output before serialization errors
+    let pendingDone = null;
+    const quadDone = error => {
+      const done = pendingDone;
+      pendingDone = null;
+      if (error) this._pushBuffer();
+      done(error);
+    };
     this._transform = (quad, encoding, done) => {
-      writer.addQuad(quad, done);
+      pendingDone = done;
+      writer.addQuad(quad, quadDone);
     };
     this._flush = done => {
       writer.end(done);
     };
   }
 
+  // ### `_pushBuffer` flushes coalesced output to the stream queue
+  _pushBuffer() {
+    this._clearFlushTimer();
+    if (this._buffer !== '') {
+      this.push(this._buffer);
+      this._buffer = '';
+    }
+  }
+
+  // ### `_armFlushTimer` schedules a partial-chunk flush
+  _armFlushTimer() {
+    this._flushTimer = setTimeout(() => {
+      this._flushTimer = null;
+      this._pushBuffer();
+    }, this._flushDelay);
+    // Browser timers do not implement `unref`
+    this._flushTimer.unref && this._flushTimer.unref();
+  }
+
+  // ### `_clearFlushTimer` cancels a scheduled flush
+  _clearFlushTimer() {
+    if (this._flushTimer !== null) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = null;
+    }
+  }
+
+  // ### `_destroy` cancels a scheduled flush, so it cannot fire afterwards
+  _destroy(error, callback) {
+    this._clearFlushTimer();
+    super._destroy(error, callback);
+  }
+
   // ### Serializes a stream of quads
   import(stream) {
     stream.on('data', quad => {
@@ -47,6 +100,7 @@ class N3StreamWriter extends _readableStream.Transform {
       this.end();
     });
     stream.on('error', error => {
+      this._pushBuffer();
       this.emit('error', error);
     });
     stream.on('prefix', (prefix, iri) => {

package/package.json

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

package/src/N3Lexer.js

@@ -4,14 +4,18 @@ import namespaces from './IRIs';
 
 const { xsd } = namespaces;
 
-// Regular expression and replacement string to escape N3 strings
+// Regular expression and replacement strings to unescape N3 strings
 const escapeSequence = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{8})|\\([^])/g;
-const escapeReplacements = {
+// Fixed escape sequences allowed in string literals (ECHAR)
+const stringEscapeReplacements = {
   '\\': '\\', "'": "'", '"': '"',
   'n': '\n', 'r': '\r', 't': '\t', 'f': '\f', 'b': '\b',
+};
+// Fixed escape sequences allowed in local names of prefixed names (PN_LOCAL_ESC)
+const localNameEscapeReplacements = {
   '_': '_', '~': '~', '.': '.', '-': '-', '!': '!', '$': '$', '&': '&',
-  '(': '(', ')': ')', '*': '*', '+': '+', ',': ',', ';': ';', '=': '=',
-  '/': '/', '?': '?', '#': '#', '@': '@', '%': '%',
+  "'": "'", '(': '(', ')': ')', '*': '*', '+': '+', ',': ',', ';': ';',
+  '=': '=', '/': '/', '?': '?', '#': '#', '@': '@', '%': '%',
 };
 const illegalIriChars = /[\x00-\x20<>\\"\{\}\|\^\`]/;
 
@@ -152,7 +156,7 @@ export default class N3Lexer {
           type = 'IRI', value = match[1];
         // Try to find a full IRI with escape sequences
         else if (match = this._iri.exec(input)) {
-          value = this._unescape(match[1]);
+          value = this._unescape(match[1], stringEscapeReplacements);
           if (value === null || illegalIriChars.test(value))
             return reportSyntaxError(this);
           type = 'IRI';
@@ -382,7 +386,7 @@ export default class N3Lexer {
         // Therefore, try inserting a space if we're at the end of the input.
         else if ((match = this._prefixed.exec(input)) ||
                  inputFinished && (match = this._prefixed.exec(`${input} `)))
-          type = 'prefixed', prefix = match[1] || '', value = this._unescape(match[2]);
+          type = 'prefixed', prefix = match[1] || '', value = this._unescape(match[2], localNameEscapeReplacements);
       }
 
       // A type token is special: it can only be emitted after an IRI or prefixed name is read
@@ -427,8 +431,9 @@ export default class N3Lexer {
     function reportSyntaxError(self) { callback(self._syntaxError(/^\S*/.exec(input)[0])); }
   }
 
-  // ### `_unescape` replaces N3 escape codes by their corresponding characters
-  _unescape(item) {
+  // ### `_unescape` replaces N3 escape codes by their corresponding characters,
+  // allowing only the fixed escape sequences from the given replacement table
+  _unescape(item, replacements) {
     let invalid = false;
     const replaced = item.replace(escapeSequence, (sequence, unicode4, unicode8, escapedChar) => {
       // 4-digit unicode character
@@ -451,8 +456,8 @@ export default class N3Lexer {
           String.fromCharCode(0xD800 + ((charCode -= 0x10000) >> 10), 0xDC00 + (charCode & 0x3FF));
       }
       // fixed escape sequence
-      if (escapedChar in escapeReplacements)
-        return escapeReplacements[escapedChar];
+      if (escapedChar in replacements)
+        return replacements[escapedChar];
       // invalid escape sequence
       invalid = true;
       return '';
@@ -488,7 +493,7 @@ export default class N3Lexer {
               openingLength === 3 && this._lineMode)
             break;
           this._line += lines;
-          return { value: this._unescape(raw), matchLength };
+          return { value: this._unescape(raw, stringEscapeReplacements), matchLength };
         }
         closingPos++;
       }

package/src/N3Parser.js

@@ -538,8 +538,28 @@ export default class N3Parser {
       // Start a new formula
       if (!this._n3Mode)
         return this._error('Unexpected graph', token);
-      this._saveContext('formula', this._graph, this._subject, this._predicate,
-                        this._graph = this._factory.blankNode());
+      // The formula is an item of the list,
+      // so it must be linked in the list's graph before the graph changes
+      list = this._factory.blankNode();
+      item = this._factory.blankNode();
+      // Is this the first element of the list?
+      if (previousList === null) {
+        // This list is either the subject or the object of its parent
+        if (parent.predicate === null)
+          parent.subject = list;
+        else
+          parent.object = list;
+      }
+      else {
+        // Continue the previous list with the current list
+        this._emit(previousList, this.RDF_REST, list, this._graph);
+      }
+      // Output the item
+      this._emit(list, this.RDF_FIRST, item, this._graph);
+      // Stack the current list quad and start the formula
+      this._saveContext('formula', this._graph, list, this.RDF_FIRST,
+                        this._graph = item);
+      this._subject = null;
       return this._readSubject;
     case '<<(':
       this._saveContext('<<(', this._graph, null, null, null);

package/src/N3StreamWriter.js

@@ -2,27 +2,89 @@
 import { Transform } from 'readable-stream';
 import N3Writer from './N3Writer';
 
+const MIN_CHUNK_SIZE = 16 * 1024;
+const DEFAULT_FLUSH_DELAY_MS = 20;
+
 // ## Constructor
 export default class N3StreamWriter extends Transform {
   constructor(options) {
     super({ encoding: 'utf8', writableObjectMode: true });
 
+    // Coalesce serialized fragments into larger stream chunks
+    this._buffer = '';
+
+    // Flush partial chunks after a bounded delay
+    this._flushTimer = null;
+    this._flushDelay = options && options.flushDelay !== undefined ?
+      options.flushDelay : DEFAULT_FLUSH_DELAY_MS;
+
     // Set up writer with a dummy stream object
     const writer = this._writer = new N3Writer({
-      write: (quad, encoding, callback) => { this.push(quad); callback && callback(); },
-      end: callback => { this.push(null); callback && callback(); },
+      write: (chunk, encoding, callback) => {
+        this._buffer += chunk;
+        if (this._buffer.length >= MIN_CHUNK_SIZE)
+          this._pushBuffer();
+        else if (this._flushTimer === null)
+          this._armFlushTimer();
+        callback && callback();
+      },
+      end: callback => { this._pushBuffer(); this.push(null); callback && callback(); },
     }, options);
 
-    // Implement Transform methods on top of writer
-    this._transform = (quad, encoding, done) => { writer.addQuad(quad, done); };
+    // Flush buffered output before serialization errors
+    let pendingDone = null;
+    const quadDone = error => {
+      const done = pendingDone;
+      pendingDone = null;
+      if (error)
+        this._pushBuffer();
+      done(error);
+    };
+    this._transform = (quad, encoding, done) => {
+      pendingDone = done;
+      writer.addQuad(quad, quadDone);
+    };
     this._flush = done => { writer.end(done); };
   }
 
+  // ### `_pushBuffer` flushes coalesced output to the stream queue
+  _pushBuffer() {
+    this._clearFlushTimer();
+    if (this._buffer !== '') {
+      this.push(this._buffer);
+      this._buffer = '';
+    }
+  }
+
+  // ### `_armFlushTimer` schedules a partial-chunk flush
+  _armFlushTimer() {
+    this._flushTimer = setTimeout(() => {
+      this._flushTimer = null;
+      this._pushBuffer();
+    }, this._flushDelay);
+    // Browser timers do not implement `unref`
+    this._flushTimer.unref && this._flushTimer.unref();
+  }
+
+  // ### `_clearFlushTimer` cancels a scheduled flush
+  _clearFlushTimer() {
+    if (this._flushTimer !== null) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = null;
+    }
+  }
+
+  // ### `_destroy` cancels a scheduled flush, so it cannot fire afterwards
+  _destroy(error, callback) {
+    this._clearFlushTimer();
+    super._destroy(error, callback);
+  }
+
 // ### Serializes a stream of quads
   import(stream) {
     stream.on('data',   quad => { this.write(quad); });
     stream.on('end',    () => { this.end(); });
-    stream.on('error',  error => { this.emit('error', error); });
+    stream.on('error',  error => { this._pushBuffer(); this.emit('error', error); });
     stream.on('prefix', (prefix, iri) => { this._writer.addPrefix(prefix, iri); });
     return this;
   }