n3 3.0.0-alpha.5 → 3.0.0-alpha.7

package/src/N3Store.js

@@ -1,5 +1,5 @@
 // **N3Store** objects store N3 quads by graph in memory.
-import { Readable } from 'readable-stream';
+import { Readable, finished } from 'readable-stream';
 import { default as N3DataFactory, termToId, termFromId } from './N3DataFactory';
 import namespaces from './IRIs';
 import { isDefaultGraph } from './N3Util';
@@ -603,10 +603,55 @@ export default class N3Store {
     return !this.readQuads(subjectOrQuad, predicate, object, graph).next().done;
   }
 
-  // ### `import` adds a stream of quads to the store
+  // ### `import` adds a stream of quads to the store.
+  // It returns the stream, wrapped such that it can also be awaited
+  // as a promise of the store (per the RDF/JS `Dataset.import` signature).
   import(stream) {
     stream.on('data', quad => { this.addQuad(quad); });
-    return stream;
+
+    // Only track completion once awaited, so unawaited imports keep the stream's behavior
+    const store = this;
+    let promise = null;
+    function completion() {
+      return promise || (promise = new Promise((resolve, reject) => {
+        let stopListening = null;
+        function settle(error) {
+          stopListening();
+          error ? reject(error) : resolve(store);
+        }
+        try {
+          stopListening = finished(stream, { readable: true, writable: false }, settle);
+        }
+        // RDF/JS streams that are not Node.js streams only signal their end and errors
+        // and must be awaited before they finish
+        catch {
+          stopListening = () => {
+            if (stream.removeListener) {
+              stream.removeListener('end', onFinish);
+              stream.removeListener('error', settle);
+            }
+          };
+          function onFinish() { settle(); }
+          stream.on('end', onFinish);
+          stream.on('error', settle);
+        }
+      }));
+    }
+    const thenable = {
+      then(onFulfilled, onRejected) { return completion().then(onFulfilled, onRejected); },
+      catch(onRejected) { return completion().catch(onRejected); },
+      finally(onFinally) { return completion().finally(onFinally); },
+    };
+    // Return a wrapper that behaves as the stream, but is also awaitable
+    return new Proxy(stream, {
+      get(target, property) {
+        if (property === 'then' || property === 'catch' || property === 'finally')
+          return thenable[property];
+        const value = target[property];
+        // Methods run on the stream itself, which may rely on private fields
+        return typeof value === 'function' ? value.bind(target) : value;
+      },
+    });
   }
 
   // ### `removeQuad` removes a quad from the store if it exists
@@ -649,9 +694,12 @@ export default class N3Store {
   }
 
   // ### `removeQuads` removes multiple quads from the store
+  // returns `true` if all quads were removed, `false` if some were not found
   removeQuads(quads) {
+    let removed = true;
     for (let i = 0; i < quads.length; i++)
-      this.removeQuad(quads[i]);
+      removed = this.removeQuad(quads[i]) && removed;
+    return removed;
   }
 
   // ### `remove` removes a stream of quads from the store

package/src/N3Writer.js

@@ -24,6 +24,9 @@ const escape    = /["\\\t\n\r\b\f\u0000-\u0019\ud800-\udbff]/,
       '\n': '\\n', '\r': '\\r', '\b': '\\b', '\f': '\\f',
     };
 
+// Characters that a version label cannot contain
+const invalidVersionLabel = /["\\\u0000-\u001f\u007f]|[\ud800-\udbff](?![\udc00-\udfff])|(?:^|[^\ud800-\udbff])[\udc00-\udfff]/;
+
 // ## Placeholder class to represent already pretty-printed terms
 class SerializedTerm extends Term {
   // Pretty-printed nodes are not equal to any other node
@@ -60,12 +63,19 @@ export default class N3Writer {
       this._endStream = options.end === undefined ? true : !!options.end;
     }
 
+    // A version label is written as-is, so it cannot contain characters that need escaping,
+    // nor unpaired surrogates (which cannot be encoded)
+    if (options.version && invalidVersionLabel.test(options.version))
+      throw new Error(`Invalid version label: ${JSON.stringify(options.version)}`);
+
     // Initialize writer, depending on the format
     this._subject = null;
     if (!(/triple|quad/i).test(options.format)) {
       this._lineMode = false;
       this._escape = escape, this._escapeAll = escapeAll, this._characterReplacer = characterReplacer;
       this._graph = DEFAULTGRAPH;
+      if (options.version)
+        this._write(`@version "${options.version}".\n`);
       this._prefixIRIs = Object.create(null);
       // Escaped prefix IRIs and names for the prefix matcher, computed once per prefix
       this._prefixPatterns = Object.create(null);
@@ -82,6 +92,8 @@ export default class N3Writer {
       // N-Triples and N-Quads are written in their canonical form
       this._escape = canonicalEscape, this._escapeAll = canonicalEscapeAll;
       this._characterReplacer = canonicalCharacterReplacer;
+      if (options.version)
+        this._write(`VERSION "${options.version}"\n`);
     }
   }
 
@@ -97,6 +109,15 @@ export default class N3Writer {
     this._outputStream.write(string, 'utf8', callback);
   }
 
+  // ### `_endStatement` finishes a pending statement and closes an open graph block
+  _endStatement() {
+    if (this._subject !== null) {
+      this._write(this._inDefaultGraph ? '.\n' : '\n}\n');
+      this._subject = null;
+      this._graph = DEFAULTGRAPH;
+    }
+  }
+
   // ### `_writeQuad` writes the quad to the output stream
   _writeQuad(subject, predicate, object, graph, done) {
     try {
@@ -324,10 +345,7 @@ export default class N3Writer {
         iri = iri.value;
       hasPrefixes = true;
       // Finish a possible pending quad
-      if (this._subject !== null) {
-        this._write(this._inDefaultGraph ? '.\n' : '\n}\n');
-        this._subject = null, this._graph = '';
-      }
+      this._endStatement();
       // Store and write the prefix
       this._prefixIRIs[iri] = (prefix += ':');
       this._prefixPatterns[iri] = escapeRegex(iri);
@@ -406,10 +424,7 @@ export default class N3Writer {
   // ### `end` signals the end of the output stream
   end(done) {
     // Finish a possible pending quad
-    if (this._subject !== null) {
-      this._write(this._inDefaultGraph ? '.\n' : '\n}\n');
-      this._subject = null;
-    }
+    this._endStatement();
     // Disallow further writing
     this._write = this._blockedWrite;