n3 3.0.0-alpha.4 → 3.0.0-alpha.5

package/src/N3Parser.js

@@ -47,7 +47,16 @@ export default class N3Parser {
       this._resolveRelativeIRI = iri => { return null; };
     this._blankNodePrefix = typeof options.blankNodePrefix !== 'string' ? '' :
                               options.blankNodePrefix.replace(/^(?!_:)/, '_:');
-    this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3, isImpliedBy: this._isImpliedBy });
+    // Map the token types of additional directives (@name and NAME) to their names
+    this._directives = null;
+    if (options.directives) {
+      this._directives = Object.create(null);
+      for (const name of options.directives)
+        this._directives[`@${name.toLowerCase()}`] = this._directives[name.toUpperCase()] = name;
+    }
+    this._lexer = options.lexer || new N3Lexer({
+      lineMode: isLineMode, n3: isN3, isImpliedBy: this._isImpliedBy, directives: options.directives,
+    });
     // Disable explicit quantifiers by default
     this._explicitQuantifiers = !!options.explicitQuantifiers;
     // Scope blank node labels to formulas only, unless explicitly disabled
@@ -55,6 +64,10 @@ export default class N3Parser {
     // Disable parsing of unsupported versions by default
     this._parseUnsupportedVersions = !!options.parseUnsupportedVersions;
     this._version = options.version;
+    // Maximum nesting depth of triple terms (default 1024; Infinity disables the limit)
+    const maxTripleTermDepth = options.maxTripleTermDepth;
+    this._maxTripleTermDepth = maxTripleTermDepth === Infinity ||
+      Number.isInteger(maxTripleTermDepth) && maxTripleTermDepth >= 0 ? maxTripleTermDepth : 1024;
   }
 
   // ## Static class methods
@@ -83,12 +96,30 @@ export default class N3Parser {
       const path = queryPos < 0 ? baseIRI : baseIRI.substr(0, queryPos);
       this._basePath   = baseIRI.indexOf('/') < 0 ? baseIRI :
                          path.substr(0, path.lastIndexOf('/') + 1);
-      baseIRI = baseIRI.match(/^(?:([a-z][a-z0-9+.-]*:))?(?:\/\/[^\/]*)?/i);
+      const base = baseIRI;
+      baseIRI = baseIRI.match(/^(?:([a-z][a-z0-9+.-]*:))?(\/\/[^\/?#]*)?/i);
       this._baseRoot   = baseIRI[0];
       this._baseScheme = baseIRI[1];
+      // If the base has an authority but an empty path,
+      // relative IRIs merge under the path '/' (RFC 3986 §5.2.3)
+      if (baseIRI[2] !== undefined && (base.length === this._baseRoot.length || base[this._baseRoot.length] === '?'))
+        this._basePath = `${this._baseRoot}/`;
     }
   }
 
+  // ### `_enterTripleTerm` stores the current parsing context when entering a triple term,
+  // failing if triple terms nest deeper than the maximum depth
+  _enterTripleTerm(type, subject, predicate, token) {
+    if (this._tripleTermDepth >= this._maxTripleTermDepth) {
+      this._error(`Triple terms nested deeper than ${this._maxTripleTermDepth} level${this._maxTripleTermDepth === 1 ? '' : 's'}`, token);
+      return false;
+    }
+    this._tripleTermDepth++;
+    this._saveContext(type, this._graph, subject, predicate, null);
+    this._graph = null;
+    return true;
+  }
+
   // ### `_saveContext` stores the current parsing context
   // when entering a new scope (list, blank node, formula)
   _saveContext(type, graph, subject, predicate, object) {
@@ -207,8 +238,13 @@ export default class N3Parser {
     case 'GRAPH':
       if (this._supportsNamedGraphs)
         return this._readNamedGraphLabel;
-    // Otherwise, the next token must be a subject
+    // Otherwise, the next token must be a subject, unless it is an additional directive
     default:
+      if (this._directives !== null && token.type in this._directives && this._graph === null) {
+        this._sparqlStyle = token.type[0] !== '@';
+        this._directiveCallback(this._directives[token.type]);
+        return this._readDeclarationPunctuation;
+      }
       return this._readSubject(token);
     }
   }
@@ -339,13 +375,9 @@ export default class N3Parser {
     case '<<(':
       if (!this._n3Mode)
         return this._error('Disallowed triple term as subject', token);
-      this._saveContext('<<(', this._graph, null, null, null);
-      this._graph = null;
-      return this._readSubject;
+      return this._enterTripleTerm('<<(', null, null, token) && this._readSubject;
     case '<<':
-      this._saveContext('<<', this._graph, null, null, null);
-      this._graph = null;
-      return this._readSubject;
+      return this._enterTripleTerm('<<', null, null, token) && this._readSubject;
     default:
       // Read the subject entity
       if ((this._subject = this._readEntity(token)) === undefined)
@@ -490,13 +522,9 @@ export default class N3Parser {
                         this._graph = this._factory.blankNode());
       return this._readInFormulaContext;
     case '<<(':
-      this._saveContext('<<(', this._graph, this._subject, this._predicate, null);
-      this._graph = null;
-      return this._readSubject;
+      return this._enterTripleTerm('<<(', this._subject, this._predicate, token) && this._readSubject;
     case '<<':
-      this._saveContext('<<', this._graph, this._subject, this._predicate, null);
-      this._graph = null;
-      return this._readSubject;
+      return this._enterTripleTerm('<<', this._subject, this._predicate, token) && this._readSubject;
     default:
       // Read the object entity
       if ((this._object = this._readEntity(token)) === undefined)
@@ -716,13 +744,9 @@ export default class N3Parser {
       this._subject = null;
       return this._readInFormulaContext;
     case '<<(':
-      this._saveContext('<<(', this._graph, null, null, null);
-      this._graph = null;
-      next = this._readSubject;
-      break;
     case '<<':
-      this._saveContext('<<', this._graph, null, null, null);
-      this._graph = null;
+      if (!this._enterTripleTerm(token.type, null, null, token))
+        return;
       next = this._readSubject;
       break;
     default:
@@ -1272,6 +1296,7 @@ export default class N3Parser {
     const quad = this._createQuad(this._subject, this._predicate, this._object,
         this._graph, this._inversePredicate);
     this._restoreContext('<<(', token);
+    this._tripleTermDepth--;
 
     // If we're in a list, continue processing that list
     const stack = this._contextStack, parent = stack.length && stack[stack.length - 1];
@@ -1307,6 +1332,7 @@ export default class N3Parser {
     this._tripleTerm = null;
     const reifier = this._readTripleTerm();
     this._restoreContext('<<', token);
+    this._tripleTermDepth--;
 
     // // If we're in a list, continue processing that list
     const stack = this._contextStack, parent = stack.length && stack[stack.length - 1];
@@ -1540,8 +1566,13 @@ export default class N3Parser {
     }
     // Resolve root-relative IRIs at the root of the base IRI
     case '/':
-      // Resolve scheme-relative IRIs to the scheme
-      return (iri[1] === '/' ? this._baseScheme : this._baseRoot) + this._removeDotSegments(iri);
+      // Resolve scheme-relative IRIs to the scheme,
+      // keeping the reference's authority intact (RFC 3986 §5.2.4)
+      if (iri[1] !== '/')
+        return this._baseRoot + this._removeDotSegments(iri);
+      // Without a base scheme, a leading ':' marks where the authority starts
+      return this._baseScheme ? this._removeDotSegments(this._baseScheme + iri) :
+        this._removeDotSegments(`:${iri}`).substr(1);
     // Resolve all other IRIs at the base IRI's path
     default:
       // Relative IRIs cannot contain a colon in the first path segment
@@ -1566,8 +1597,8 @@ export default class N3Parser {
         if (pathStart < 0) {
           // Skip two slashes before the authority
           if (iri[++i] === '/' && iri[++i] === '/')
-            // Skip to slash after the authority
-            while ((pathStart = i + 1) < length && iri[pathStart] !== '/')
+            // Skip to the end of the authority
+            while ((pathStart = i + 1) < length && iri[pathStart] !== '/' && iri[pathStart] !== '?' && iri[pathStart] !== '#')
               i = pathStart;
         }
         break;
@@ -1618,13 +1649,14 @@ export default class N3Parser {
   parse(input, quadCallback, prefixCallback, versionCallback) {
     // The second parameter also accepts an object of named callbacks.
     // As a second and third parameter it still accepts a separate quadCallback and prefixCallback for backward compatibility as well
-    let onQuad, onPrefix, onComment, onVersion, onToken, onTokenEnd;
+    let onQuad, onPrefix, onComment, onVersion, onDirective, onToken, onTokenEnd;
     if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion ||
-                         quadCallback.onToken || quadCallback.onTokenEnd)) {
+                         quadCallback.onDirective || quadCallback.onToken || quadCallback.onTokenEnd)) {
       onQuad = quadCallback.onQuad;
       onPrefix = quadCallback.onPrefix;
       onComment = quadCallback.onComment;
       onVersion = quadCallback.onVersion;
+      onDirective = quadCallback.onDirective;
       onToken = quadCallback.onToken;
       onTokenEnd = quadCallback.onTokenEnd;
     }
@@ -1645,6 +1677,7 @@ export default class N3Parser {
       this._prefixes[''] = this._resolveIRI('#');
     this._prefixCallback = onPrefix || noop;
     this._versionCallback = onVersion || noop;
+    this._directiveCallback = onDirective || noop;
     this._inversePredicate = false;
     this._expectOf = false;
     this._quantified = Object.create(null);
@@ -1652,6 +1685,7 @@ export default class N3Parser {
     this._prefixChanges = null;
     this._quantifiedChanges = null;
     this._emptyFormula = false;
+    this._tripleTermDepth = 0;
 
     let readToken = token => {
       return this._readCallback = this._readCallback(token);

package/src/N3Reasoner.js

@@ -156,7 +156,7 @@ export default class N3Reasoner {
   }
 
   _createRule({ premise, conclusion }) {
-    const varMapping = {};
+    const varMapping = Object.create(null);
 
     const toId = value => value.termType === 'Variable' ?
       // If the term is a variable, then create an empty object that values can be placed into

package/src/N3Store.js

@@ -118,6 +118,35 @@ function difference(s1, s2, depth = 4) {
   return target;
 }
 
+// Returns the key of a term in the entity index.
+// Keys mark the term type by their first character, so the IRI of a named node
+// that starts with such a marker (as relative IRIs can) is wrapped in < and >.
+const markedIRI = /^[?_"[.<]/;
+function entityKey(term) {
+  // Strings are term ids, which only need wrapping when they are IRIs starting with <
+  if (typeof term === 'string')
+    return term.charCodeAt(0) !== 0x3C || term === '<>' ? term : `<${term}>`;
+  // IDs of IRIs usually start with a lowercase scheme letter, which never marks a term type
+  const id = termToId(term);
+  if (id.charCodeAt(0) >= 0x61 || !term)
+    return id;
+  // Keys of quoted triples are built from the keys of their components
+  if (term.termType === 'Quad')
+    return JSON.stringify(quadKeyParts(term));
+  return term.termType !== 'NamedNode' || !markedIRI.test(term.value) ? id : `<${term.value}>`;
+}
+
+// Returns the keys of the components of a quad, nested like the parts of its internal id
+function quadKeyParts(quad) {
+  const parts = [nestedKey(quad.subject), nestedKey(quad.predicate), nestedKey(quad.object)];
+  if (quad.graph && !isDefaultGraph(quad.graph))
+    parts.push(nestedKey(quad.graph));
+  return parts;
+}
+function nestedKey(term) {
+  return term.termType === 'Quad' ? quadKeyParts(term) : entityKey(term);
+}
+
 // ## Constructor
 export class N3EntityIndex {
   constructor(options = {}) {
@@ -135,6 +164,10 @@ export class N3EntityIndex {
   }
 
   _termFromId(id) {
+    // A key in < and > is a named node
+    if (id[0] === '<')
+      return this._factory.namedNode(id.substring(1, id.length - 1));
+    // A key starting with . is a quoted triple
     if (id[0] === '.') {
       const entities = this._entities;
       const terms = id.split('.');
@@ -159,18 +192,34 @@ export class N3EntityIndex {
       return s && p && o && (isDefaultGraph(term.graph) || (g = this._termToNumericId(term.graph))) &&
         this._ids[g ? `.${s}.${p}.${o}.${g}` : `.${s}.${p}.${o}`];
     }
-    return this._ids[termToId(term)];
+    return typeof term === 'string' ? this._stringToNumericId(term) : this._ids[entityKey(term)];
+  }
+
+  // Returns the numeric id of a term given as a string id
+  _stringToNumericId(term) {
+    // The string is the key unless it is an IRI starting with <. Read the first character
+    // from the stored key after a match, which is cheaper than from a concatenated string.
+    const id = this._ids[term];
+    if (id ? this._entities[id].charCodeAt(0) !== 0x3C : term.charCodeAt(0) !== 0x3C)
+      return id;
+    return term === '<>' ? id : this._ids[`<${term}>`];
   }
 
   _termToNewNumericId(term) {
+    if (typeof term === 'string')
+      return this._stringToNumericId(term) || this._addEntity(entityKey(term));
     // This assumes that no graph term is present - we may wish to error if there is one
     const str = term && term.termType === 'Quad' ?
       `.${this._termToNewNumericId(term.subject)}.${this._termToNewNumericId(term.predicate)}.${this._termToNewNumericId(term.object)}${
         isDefaultGraph(term.graph) ? '' : `.${this._termToNewNumericId(term.graph)}`
       }`
-      : termToId(term);
+      : entityKey(term);
+
+    return this._ids[str] || this._addEntity(str);
+  }
 
-    return this._ids[str] || (this._ids[this._entities[++this._id] = str] = this._id);
+  _addEntity(key) {
+    return this._ids[this._entities[++this._id] = key] = this._id;
   }
 
   createBlankNode(suggestedName) {
@@ -1382,7 +1431,7 @@ function intersectMatchPatterns(left, right) {
     const leftTerm = left[i], rightTerm = right[i];
     if (leftTerm === null || leftTerm === undefined)
       result[i] = rightTerm;
-    else if (rightTerm === null || rightTerm === undefined || termToId(leftTerm) === termToId(rightTerm))
+    else if (rightTerm === null || rightTerm === undefined || entityKey(leftTerm) === entityKey(rightTerm))
       result[i] = leftTerm;
     else
       return false;
@@ -1433,10 +1482,10 @@ class DatasetCoreAndReadableStream extends Readable {
   _matchesQuad(quad) {
     const { subject, predicate, object, graph } = this;
     return !this._matchesNothing &&
-      (subject === null || subject === undefined || termToId(subject) === termToId(quad.subject)) &&
-      (predicate === null || predicate === undefined || termToId(predicate) === termToId(quad.predicate)) &&
-      (object === null || object === undefined || termToId(object) === termToId(quad.object)) &&
-      (graph === null || graph === undefined || termToId(graph) === termToId(quad.graph));
+      (subject === null || subject === undefined || entityKey(subject) === entityKey(quad.subject)) &&
+      (predicate === null || predicate === undefined || entityKey(predicate) === entityKey(quad.predicate)) &&
+      (object === null || object === undefined || entityKey(object) === entityKey(quad.object)) &&
+      (graph === null || graph === undefined || entityKey(graph) === entityKey(quad.graph));
   }
 
   // ### `_assertMatchesPattern` rejects a Quad outside this view.

package/src/N3StreamParser.js

@@ -16,6 +16,8 @@ export default class N3StreamParser extends Transform {
       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); },
+        // Emit additional directives through the `directive` event
+      onDirective: name => { this.emit('directive', name); },
     };
 
     if (options && options.comments)

package/src/N3Writer.js

@@ -8,10 +8,17 @@ import { escapeRegex } from './Util';
 const DEFAULTGRAPH = N3DataFactory.defaultGraph();
 
 const { rdf, xsd } = namespaces;
+const { hasOwnProperty } = Object.prototype;
 
-// Characters in literals that require escaping
+// Characters that require escaping in Turtle, TriG, and N3,
+// where characters outside the Basic Multilingual Plane are escaped as well
 const escape    = /["\\\t\n\r\b\f\u0000-\u0019\ud800-\udbff]/,
     escapeAll = /["\\\t\n\r\b\f\u0000-\u0019]|[\ud800-\udbff][\udc00-\udfff]/g,
+    // Characters that require escaping in canonical N-Triples and N-Quads:
+    // U+0000–U+001F, `"`, `\`, U+007F, U+FFFE, and U+FFFF.
+    // A negated class is as fast to test as a shorter class listing characters.
+    canonicalEscape    = /[^ !#-\[\]-~\u0080-\uFFFD]/,
+    canonicalEscapeAll = /[^ !#-\[\]-~\u0080-\uFFFD]/g,
     escapedCharacters = {
       '\\': '\\\\', '"': '\\"', '\t': '\\t',
       '\n': '\\n', '\r': '\\r', '\b': '\\b', '\f': '\\f',
@@ -57,8 +64,11 @@ export default class N3Writer {
     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;
       this._prefixIRIs = Object.create(null);
+      // Escaped prefix IRIs and names for the prefix matcher, computed once per prefix
+      this._prefixPatterns = Object.create(null);
       if (options.baseIRI) {
         this._baseIri = new BaseIRI(options.baseIRI);
         if (options.writeBase !== false)
@@ -69,6 +79,9 @@ export default class N3Writer {
     else {
       this._lineMode = true;
       this._writeQuad = this._writeQuadLine;
+      // N-Triples and N-Quads are written in their canonical form
+      this._escape = canonicalEscape, this._escapeAll = canonicalEscapeAll;
+      this._characterReplacer = canonicalCharacterReplacer;
     }
   }
 
@@ -161,7 +174,7 @@ export default class N3Writer {
     // A blank node or list is represented as-is
     if (entity.termType !== 'NamedNode') {
       // If it is a list head, pretty-print it
-      if (this._lists && (entity.value in this._lists))
+      if (this._lists && hasOwnProperty.call(this._lists, entity.value))
         entity = this.list(this._lists[entity.value]);
       // Terms from this library already hold their serialization as id
       if (entity instanceof Term)
@@ -174,10 +187,10 @@ export default class N3Writer {
       iri = this._baseIri.toRelative(iri);
     }
     // Escape special characters
-    if (escape.test(iri))
-      iri = iri.replace(escapeAll, characterReplacer);
+    if (this._escape.test(iri))
+      iri = iri.replace(this._escapeAll, this._characterReplacer);
     // Try to represent the IRI as prefixed name, unless no prefixes were added
-    const prefixMatch = this._hasPrefixes ? this._prefixRegex.exec(iri) : null;
+    const prefixMatch = this._hasPrefixes ? (this._prefixRegex || this._createPrefixRegex()).exec(iri) : null;
     return !prefixMatch ? `<${iri}>` : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
   }
 
@@ -185,8 +198,8 @@ export default class N3Writer {
   _encodeLiteral(literal) {
     // Escape special characters
     let value = literal.value;
-    if (escape.test(value))
-      value = value.replace(escapeAll, characterReplacer);
+    if (this._escape.test(value))
+      value = value.replace(this._escapeAll, this._characterReplacer);
 
     // Write a language-tagged literal
     const language = literal.language;
@@ -257,11 +270,13 @@ export default class N3Writer {
 
   // ### `_encodeQuad` encodes an RDF-star quad
   _encodeQuad({ subject, predicate, object, graph }) {
-    return `<<(${
+    // Canonical N-Triples and N-Quads put spaces inside the delimiters
+    const space = this._lineMode ? ' ' : '';
+    return `<<(${space}${
       this._encodeSubject(subject)} ${
       this._encodePredicate(predicate)} ${
       this._encodeObject(object)}${
-      isDefaultGraph(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`})>>`;
+      isDefaultGraph(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`}${space})>>`;
   }
 
   // ### `_blockedWrite` replaces `_write` after the writer has been closed
@@ -315,21 +330,27 @@ export default class N3Writer {
       }
       // Store and write the prefix
       this._prefixIRIs[iri] = (prefix += ':');
+      this._prefixPatterns[iri] = escapeRegex(iri);
       this._write(`@prefix ${prefix} <${iri}>.\n`);
     }
-    // Recreate the prefix matcher
+    // Recreate the prefix matcher when it is next needed, so that adding
+    // prefixes one by one does not rebuild it for every prefix
     if (hasPrefixes) {
       this._hasPrefixes = true;
-      let IRIlist = '';
-      for (const prefixIRI in this._prefixIRIs)
-        IRIlist += IRIlist ? `|${prefixIRI}` : prefixIRI;
-      IRIlist = escapeRegex(IRIlist, /[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
-      this._prefixRegex = new RegExp(`^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
+      this._prefixRegex = null;
     }
     // End a prefix block with a newline
     this._write(hasPrefixes ? '\n' : '', done);
   }
 
+  // ### `_createPrefixRegex` creates the matcher for the current prefixes
+  _createPrefixRegex() {
+    let IRIlist = '';
+    for (const prefixIRI in this._prefixPatterns)
+      IRIlist += IRIlist ? `|${this._prefixPatterns[prefixIRI]}` : this._prefixPatterns[prefixIRI];
+    return this._prefixRegex = new RegExp(`^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
+  }
+
   // ### `blank` creates a blank node with the given content
   blank(predicate, object) {
     let children = predicate, child, length;
@@ -421,3 +442,14 @@ function characterReplacer(character) {
   }
   return result;
 }
+
+// Replaces a character by its canonical N-Triples escape:
+// a short escape where one exists, and an upper-case `\uXXXX` escape otherwise
+function canonicalCharacterReplacer(character) {
+  let result = escapedCharacters[character];
+  if (result === undefined) {
+    result = character.charCodeAt(0).toString(16).toUpperCase();
+    result = '\\u0000'.substr(0, 6 - result.length) + result;
+  }
+  return result;
+}

package/src/Util.js

@@ -1,3 +1,3 @@
 export function escapeRegex(regex) {
-  return regex.replace(/[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
+  return regex.replace(/[.*+?^${}()|[\]\\/-]/g, '\\$&');
 }