n3 2.2.16 → 2.4.0

package/lib/IRIs.js

@@ -11,6 +11,7 @@ var _default = exports.default = {
   xsd: {
     decimal: `${XSD}decimal`,
     boolean: `${XSD}boolean`,
+    dateTime: `${XSD}dateTime`,
     double: `${XSD}double`,
     integer: `${XSD}integer`,
     string: `${XSD}string`

package/lib/N3DataFactory.js

@@ -412,7 +412,7 @@ function literal(value, languageOrDataType) {
     return new Literal(`"${value}"@${languageOrDataType.language.toLowerCase()}${languageOrDataType.direction ? `--${languageOrDataType.direction.toLowerCase()}` : ''}`);
   }
 
-  // Automatically determine datatype for booleans and numbers
+  // Automatically determine datatype for booleans, numbers, and dates
   let datatype = languageOrDataType ? languageOrDataType.value : '';
   if (datatype === '') {
     // Convert a boolean
@@ -424,6 +424,11 @@ function literal(value, languageOrDataType) {
         if (!Number.isNaN(value)) value = value > 0 ? 'INF' : '-INF';
       }
     }
+    // Convert a valid date
+    else if (value instanceof Date && !Number.isNaN(value.getTime())) {
+      datatype = xsd.dateTime;
+      value = value.toISOString();
+    }
   }
 
   // Create a datatyped literal

package/lib/N3Parser.js

@@ -97,7 +97,7 @@ class N3Parser {
       });
       return;
     }
-    this._contextStack.push({
+    const context = {
       type,
       subject,
       predicate,
@@ -107,7 +107,14 @@ class N3Parser {
       blankPrefix: this._prefixes._,
       quantified: this._quantified,
       emptyFormula: this._emptyFormula
-    });
+    };
+    // Prefix and base declarations are scoped to their formula
+    if (type === 'formula') {
+      context.prefixes = this._prefixes;
+      context.base = [this._base, this._basePath, this._baseRoot, this._baseScheme];
+      this._prefixes = Object.create(this._prefixes);
+    }
+    this._contextStack.push(context);
     // Every new scope resets the predicate direction
     this._inversePredicate = false;
     // In N3, blank nodes are scoped to a formula
@@ -138,7 +145,10 @@ class N3Parser {
     // Restore N3 context settings
     if (this._n3Mode) {
       this._inversePredicate = context.inverse;
-      this._prefixes._ = context.blankPrefix;
+      if (type === 'formula') {
+        this._prefixes = context.prefixes;
+        [this._base, this._basePath, this._baseRoot, this._baseScheme] = context.base;
+      } else this._prefixes._ = context.blankPrefix;
       this._quantified = context.quantified;
       this._emptyFormula = context.emptyFormula;
     }
@@ -188,6 +198,28 @@ class N3Parser {
     }
   }
 
+  // ### `_readInFormulaContext` reads a token at the statement level of a formula
+  _readInFormulaContext(token) {
+    switch (token.type) {
+      case 'PREFIX':
+        this._sparqlStyle = true;
+      case '@prefix':
+        return this._readPrefix;
+      case 'BASE':
+        this._sparqlStyle = true;
+      case '@base':
+        return this._readBaseIRI;
+      default:
+        return this._readSubject(token);
+    }
+  }
+
+  // ### `_getStatementReader` returns the reader for the current statement scope
+  _getStatementReader() {
+    const context = this._contextStack[this._contextStack.length - 1];
+    return context && context.type === 'formula' ? this._readInFormulaContext : this._readInTopContext;
+  }
+
   // ### `_readEntity` reads an IRI, prefixed name, blank node, or variable
   _readEntity(token, quantifier) {
     let value;
@@ -252,7 +284,7 @@ class N3Parser {
         // Start a new formula
         if (!this._n3Mode) return this._error('Unexpected graph', token);
         this._saveContext('formula', this._graph, this._graph = this._factory.blankNode(), null, null);
-        return this._readSubject;
+        return this._readInFormulaContext;
       case '}':
         // No subject; the graph in which we are reading is closed instead
         return this._readPunctuation(token);
@@ -302,6 +334,7 @@ class N3Parser {
   // ### `_readPredicate` reads a quad's predicate
   _readPredicate(token) {
     const type = token.type;
+    let pathable = false;
     switch (type) {
       case 'inverse':
         this._inversePredicate = true;
@@ -326,6 +359,7 @@ class N3Parser {
           this._literalValue = token.value;
           return this._completePredicateLiteral;
         } else this._predicate = this._factory.literal(token.value, this._factory.namedNode(token.prefix));
+        pathable = true;
         break;
       case '(':
         // In N3, a list can be a predicate
@@ -336,14 +370,23 @@ class N3Parser {
           this._saveContext('blank', this._graph, this._subject, this._subject = this._factory.blankNode(), null);
           return this._readBlankNodeHead;
         }
+        return this._error('Disallowed blank node as predicate', token);
+      case '{':
+        // In N3, a formula can be a predicate
+        if (this._n3Mode) {
+          this._saveContext('formula', this._graph, this._subject, this._graph = this._factory.blankNode(), null);
+          return this._readSubject;
+        }
+        return this._readEntity(token);
       case 'blank':
         if (!this._n3Mode) return this._error('Disallowed blank node as predicate', token);
       default:
         if ((this._predicate = this._readEntity(token)) === undefined) return;
+        pathable = this._n3Mode;
     }
     this._validAnnotation = true;
     // The next token must be an object
-    return this._readObject;
+    return pathable ? this._getPathReader(this._readObject, 'predicate') : this._readObject;
   }
 
   // ### `_readObject` reads a quad's object
@@ -372,7 +415,7 @@ 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());
-        return this._readSubject;
+        return this._readInFormulaContext;
       case '<<(':
         this._saveContext('<<(', this._graph, this._subject, this._predicate, null);
         this._graph = null;
@@ -432,7 +475,7 @@ class N3Parser {
     // If the blank node was the object, restore previous context and read punctuation
     if (this._object !== null) return this._getContextEndReader();
     // If the blank node was the predicate, continue reading the object
-    else if (this._predicate !== null) return this._readObject;
+    else if (this._predicate !== null) return this._getPathReader(this._readObject, 'predicate');
     // If the blank node was the subject, continue reading the predicate
     else
       // If the blank node was empty, it could be a named graph label
@@ -504,7 +547,7 @@ class N3Parser {
         // Was this list the parent's predicate?
         else if (this._object === null) {
           // The next token is the object
-          next = this._readObject;
+          next = this._getPathReader(this._readObject, 'predicate');
           // No list tail if this was an empty list
           if (this._predicate === this.RDF_NIL) return next;
         }
@@ -551,7 +594,7 @@ class N3Parser {
         // 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;
+        return this._readInFormulaContext;
       case '<<(':
         this._saveContext('<<(', this._graph, null, null, null);
         this._graph = null;
@@ -662,12 +705,12 @@ class N3Parser {
       this._literalLanguage = undefined;
       token = null;
     }
-    if (component === 'subject') {
-      // A subject literal implies N3 mode, so the literal might start a path
-      const reader = this._getPathEndReader(token, this._readPredicateOrNamedGraph);
-      return reader || this._readPredicateOrNamedGraph(token);
+    if (component === 'subject' || component === 'predicate') {
+      // A subject or predicate literal implies N3 mode, so it might start a path
+      const next = component === 'subject' ? this._readPredicateOrNamedGraph : this._readObject;
+      const reader = this._getPathEndReader(token, next, component);
+      return reader || next.call(this, token);
     }
-    if (component === 'predicate') return token === null ? this._readObject : this._readObject(token);
     return this._completeObjectLiteralPost(token, listItem);
   }
 
@@ -691,15 +734,12 @@ class N3Parser {
       return this._readDirCode;
     }
 
-    // A subject literal implies N3 mode, so it might start a path.
-    if (component === 'subject') {
-      const reader = this._getPathEndReader(completed.token, next);
-      if (reader) return reader;
-    }
+    // A subject or predicate literal implies N3 mode, so it might start a path.
+    const reader = this._getPathEndReader(completed.token, next, component);
+    if (reader) return reader;
 
-    // If the token was consumed as a datatype, continue with the next component;
-    // otherwise, consume the token now
-    return completed.token === null ? next : next.call(this, completed.token);
+    // Consume the non-path token now
+    return next.call(this, completed.token);
   }
 
   // Completes a literal in subject position
@@ -764,12 +804,13 @@ class N3Parser {
     // is read as the boolean literal true, following the N3 spec tests
     // and the direction discussed in https://github.com/w3c-cg/N3/issues/185
     if (empty && this._emptyFormulaAsTrue) {
-      if (this._subject === formula) this._subject = this.N3_TRUE;else this._object = this.N3_TRUE;
+      if (this._subject === formula) this._subject = this.N3_TRUE;else if (this._predicate === formula) this._predicate = this.N3_TRUE;else this._object = this.N3_TRUE;
     }
 
-    // If the formula was the subject, continue reading the predicate.
-    // If the formula was the object, read punctuation.
-    return this._object === null ? this._readPredicate : this._getContextEndReader();
+    // Continue according to the formula's position in the enclosing statement
+    if (this._object !== null) return this._getPathReader(this._getContextEndReader(), 'object');
+    if (this._predicate !== null) return this._getPathReader(this._readObject, 'predicate');
+    return this._getPathReader(this._readPredicate, 'subject');
   }
 
   // ### `_readPunctuation` reads punctuation between quads or quad parts
@@ -789,7 +830,7 @@ class N3Parser {
       case '.':
         this._subject = null;
         this._tripleTerm = null;
-        next = this._contextStack.length ? this._readSubject : this._readInTopContext;
+        next = this._getStatementReader();
         if (inversePredicate) this._inversePredicate = false;
         break;
       // Semicolon means the subject is shared; predicate and object are different
@@ -947,10 +988,10 @@ class N3Parser {
     // SPARQL-style declarations don't have punctuation
     if (this._sparqlStyle) {
       this._sparqlStyle = false;
-      return this._readInTopContext(token);
+      return this._getStatementReader().call(this, token);
     }
     if (token.type !== '.') return this._error('Expected declaration to end with a dot', token);
-    return this._readInTopContext;
+    return this._getStatementReader();
   }
 
   // Reads a list of quantified symbols from a @forSome or @forAll statement
@@ -995,17 +1036,18 @@ class N3Parser {
   }
 
   // ### `_getPathReader` reads a potential path and then resumes with the given function
-  _getPathReader(afterPath) {
+  _getPathReader(afterPath, position) {
     this._afterPath = afterPath;
+    this._pathPosition = position || (this._predicate === null ? 'subject' : 'object');
     return this._readPath;
   }
 
   // ### `_getPathEndReader` continues reading after a term that might start a path,
   // given the pending token that follows the term (or `null` if it was consumed)
-  _getPathEndReader(token, afterPath) {
+  _getPathEndReader(token, afterPath, position) {
     // Other pending tokens are not handled here
     if (token !== null && token.type !== '!' && token.type !== '^') return null;
-    const reader = this._getPathReader(afterPath);
+    const reader = this._getPathReader(afterPath, position);
     // If no token is pending, wait for the next one; otherwise, consume it now
     return token === null ? reader : reader.call(this, token);
   }
@@ -1021,6 +1063,7 @@ class N3Parser {
         return this._readBackwardPath;
       // Not a path; resume reading where we left off
       default:
+        const afterPath = this._afterPath;
         const stack = this._contextStack,
           parent = stack.length && stack[stack.length - 1];
         // If we were reading a list item, we still need to output it
@@ -1032,7 +1075,9 @@ class N3Parser {
           // Output the list item
           this._emit(this._subject, this.RDF_FIRST, item, this._graph);
         }
-        return this._afterPath(token);
+        this._afterPath = null;
+        this._pathPosition = null;
+        return afterPath.call(this, token);
     }
   }
 
@@ -1042,10 +1087,8 @@ class N3Parser {
     const object = this._factory.blankNode();
     // The next token is the predicate
     if ((predicate = this._readEntity(token)) === undefined) return;
-    // If we were reading a subject, replace the subject by the path's object
-    if (this._predicate === null) subject = this._subject, this._subject = object;
-    // If we were reading an object, replace the subject by the path's object
-    else subject = this._object, this._object = object;
+    // Replace the path expression with the generated object in its current position
+    if (this._pathPosition === 'subject') subject = this._subject, this._subject = object;else if (this._pathPosition === 'predicate') subject = this._predicate, this._predicate = object;else subject = this._object, this._object = object;
     // Emit the path's current quad and read its next section
     this._emit(subject, predicate, object, this._graph);
     return this._readPath;
@@ -1057,10 +1100,8 @@ class N3Parser {
     let predicate, object;
     // The next token is the predicate
     if ((predicate = this._readEntity(token)) === undefined) return;
-    // If we were reading a subject, replace the subject by the path's subject
-    if (this._predicate === null) object = this._subject, this._subject = subject;
-    // If we were reading an object, replace the subject by the path's subject
-    else object = this._object, this._object = subject;
+    // Replace the path expression with the generated subject in its current position
+    if (this._pathPosition === 'subject') object = this._subject, this._subject = subject;else if (this._pathPosition === 'predicate') object = this._predicate, this._predicate = subject;else object = this._object, this._object = subject;
     // Emit the path's current quad and read its next section
     this._emit(subject, predicate, object, this._graph);
     return this._readPath;

package/package.json

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

package/src/IRIs.js

@@ -6,6 +6,7 @@ export default {
   xsd: {
     decimal: `${XSD}decimal`,
     boolean: `${XSD}boolean`,
+    dateTime: `${XSD}dateTime`,
     double:  `${XSD}double`,
     integer: `${XSD}integer`,
     string:  `${XSD}string`,

package/src/N3DataFactory.js

@@ -424,7 +424,7 @@ function literal(value, languageOrDataType) {
     return new Literal(`"${value}"@${languageOrDataType.language.toLowerCase()}${languageOrDataType.direction ? `--${languageOrDataType.direction.toLowerCase()}` : ''}`);
   }
 
-  // Automatically determine datatype for booleans and numbers
+  // Automatically determine datatype for booleans, numbers, and dates
   let datatype = languageOrDataType ? languageOrDataType.value : '';
   if (datatype === '') {
     // Convert a boolean
@@ -440,6 +440,11 @@ function literal(value, languageOrDataType) {
           value = value > 0 ? 'INF' : '-INF';
       }
     }
+    // Convert a valid date
+    else if (value instanceof Date && !Number.isNaN(value.getTime())) {
+      datatype = xsd.dateTime;
+      value = value.toISOString();
+    }
   }
 
   // Create a datatyped literal