n3 3.0.0-alpha.7 → 3.0.0-alpha.9

package/src/N3Store.js

@@ -23,101 +23,6 @@ function hasInIndex(index0, key0, key1, key2) {
   return !!index2 && key2 in index2;
 }
 
-function merge(target, source, depth = 4) {
-  let size = target[SIZE] || 0;
-  for (const key in source) {
-    if (!(key in target)) {
-      size++;
-      target[key] = depth === 0 ? null : merge(Object.create(null), source[key], depth - 1);
-    }
-    // Merge into the existing object in place,
-    // as graph objects are frozen and cannot be reassigned
-    else if (depth !== 0)
-      merge(target[key], source[key], depth - 1);
-  }
-  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
-  if (depth <= 2)
-    target[SIZE] = size;
-
-  return target;
-}
-
-/**
- * Determines the intersection of the `_graphs` index s1 and s2.
- * s1 and s2 *must* belong to Stores that share an `_entityIndex`.
- *
- * False is returned when there is no intersection; this should
- * *not* be set as the value for an index.
- */
-function intersect(s1, s2, depth = 4) {
-  let target = false, size = 0;
-
-  if (depth <= 2 && s2[SIZE] < s1[SIZE])
-    [s1, s2] = [s2, s1];
-
-  for (const key in s1) {
-    if (key in s2) {
-      const intersection = depth === 0 ? null : intersect(s1[key], s2[key], depth - 1);
-      if (intersection !== false) {
-        target = target || Object.create(null);
-        target[key] = intersection;
-        size++;
-      }
-      // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
-      // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
-      else if (depth === 3) {
-        return false;
-      }
-    }
-  }
-
-  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
-  if (depth <= 2 && target)
-    target[SIZE] = size;
-
-  return target;
-}
-
-/**
- * Determines the difference of the `_graphs` index s1 and s2.
- * s1 and s2 *must* belong to Stores that share an `_entityIndex`.
- *
- * False is returned when there is no difference; this should
- * *not* be set as the value for an index.
- */
-function difference(s1, s2, depth = 4) {
-  let target = false, size = 0;
-
-  for (const key in s1) {
-    // When the key is not in the index, then none of the triples defined by s1[key] are
-    // in s2 and so we want to copy them over to the resultant store.
-    if (!(key in s2)) {
-      target = target || Object.create(null);
-      target[key] = depth === 0 ? null : merge({}, s1[key], depth - 1);
-      size++;
-    }
-    else if (depth !== 0) {
-      const diff = difference(s1[key], s2[key], depth - 1);
-      if (diff !== false) {
-        target = target || Object.create(null);
-        target[key] = diff;
-        size++;
-      }
-      // Depth 3 is the 'subjects', 'predicates' and 'objects' keys.
-      // If the 'subjects' index is empty, so will the 'predicates' and 'objects' index.
-      else if (depth === 3) {
-        return false;
-      }
-    }
-  }
-
-  // Depth 2 is the level of the `subjects`, `predicates`, and `objects` indexes.
-  if (depth <= 2 && target)
-    target[SIZE] = size;
-
-  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 >.
@@ -242,6 +147,12 @@ export class N3EntityIndex {
   }
 }
 
+// Returns the size of a store from this copy of N3 if it is known without counting,
+// or null otherwise
+function knownSize(dataset) {
+  return dataset instanceof N3Store ? dataset._size : null;
+}
+
 // ## Constructor
 export default class N3Store {
   constructor(quads, options) {
@@ -249,6 +160,7 @@ export default class N3Store {
     this._size = 0;
     // `_graphs` contains subject, predicate, and object indexes per graph
     this._graphs = Object.create(null);
+    this._graphCount = 0;
     // `_observers` contains weak references to views notified before every mutation
     this._observers = null;
 
@@ -273,20 +185,11 @@ export default class N3Store {
 
   // ### `size` returns the number of quads in the store
   get size() {
-    // Return the quad count if if was cached
-    let size = this._size;
-    if (size !== null)
-      return size;
-
-    // Calculate the number of quads by counting to the deepest level
-    size = 0;
-    const graphs = this._graphs;
-    let subjects, subject;
-    for (const graphKey in graphs)
-      for (const subjectKey in (subjects = graphs[graphKey].subjects))
-        for (const predicateKey in (subject = subjects[subjectKey]))
-          size += subject[predicateKey][SIZE];
-    return this._size = size;
+    // The quad count is kept up to date by every change,
+    // except by reasoners from earlier versions of N3, which set it to null
+    if (this._size === null)
+      this._size = this.countQuads();
+    return this._size;
   }
 
   // ## Private methods
@@ -554,6 +457,7 @@ export default class N3Store {
       // Freezing a graph helps subsequent `add` performance,
       // and properties will never be modified anyway
       Object.freeze(graphItem);
+      this._graphCount++;
     }
 
     // Notify observers before inserting a new quad so snapshots retain their prior contents
@@ -568,11 +472,67 @@ export default class N3Store {
     this._addToIndex(graphItem.predicates, predicate, object,    subject);
     this._addToIndex(graphItem.objects,    object,    subject,   predicate);
 
-    // The cached quad count is now invalid
-    this._size = null;
+    if (this._size !== null) this._size++;
     return true;
   }
 
+  // ### `_addFromIndex` adds the quads in the given graph indexes of a store
+  // that shares this store's entity index, so no terms need to be converted.
+  // With `otherGraphs`, it only adds the quads that are not in those indexes.
+  // Index keys are strings, so the ids are converted back to the numbers that
+  // `addQuad` uses: forwarded views compare the ids they are notified with to
+  // their own numeric ids.
+  _addFromIndex(graphs, otherGraphs = null) {
+    for (const graphKey in graphs) {
+      const subjects = graphs[graphKey].subjects, other = otherGraphs && otherGraphs[graphKey];
+      const otherSubjects = other ? other.subjects : null;
+      for (const subjectKey in subjects) {
+        const subject = Number(subjectKey), predicates = subjects[subjectKey];
+        const otherPredicates = otherSubjects && otherSubjects[subjectKey];
+        for (const predicateKey in predicates) {
+          const predicate = Number(predicateKey), objects = predicates[predicateKey];
+          const otherObjects = otherPredicates && otherPredicates[predicateKey];
+          for (const objectKey in objects) {
+            if (!otherObjects || !(objectKey in otherObjects))
+              this._addQuad(subject, predicate, Number(objectKey), Number(graphKey));
+          }
+        }
+      }
+    }
+  }
+
+  // ### `_addIntersectionFromIndex` adds the quads that are in both of the
+  // given graph indexes, walking the graphs of the first and, below them,
+  // whichever index has fewer keys
+  _addIntersectionFromIndex(graphs, otherGraphs) {
+    for (const graphKey in graphs) {
+      const other = otherGraphs[graphKey];
+      if (other) {
+        let subjects = graphs[graphKey].subjects, otherSubjects = other.subjects;
+        if (otherSubjects[SIZE] < subjects[SIZE])
+          [subjects, otherSubjects] = [otherSubjects, subjects];
+        for (const subjectKey in subjects) {
+          let predicates = subjects[subjectKey], otherPredicates = otherSubjects[subjectKey];
+          if (otherPredicates) {
+            if (otherPredicates[SIZE] < predicates[SIZE])
+              [predicates, otherPredicates] = [otherPredicates, predicates];
+            for (const predicateKey in predicates) {
+              let objects = predicates[predicateKey], otherObjects = otherPredicates[predicateKey];
+              if (otherObjects) {
+                if (otherObjects[SIZE] < objects[SIZE])
+                  [objects, otherObjects] = [otherObjects, objects];
+                for (const objectKey in objects) {
+                  if (objectKey in otherObjects)
+                    this._addQuad(Number(subjectKey), Number(predicateKey), Number(objectKey), Number(graphKey));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
   // ### `addQuads` adds multiple quads to the store
   addQuads(quads) {
     for (let i = 0; i < quads.length; i++)
@@ -688,8 +648,10 @@ export default class N3Store {
     if (this._size !== null) this._size--;
 
     // Remove the graph if it is empty
-    if (graphItem.subjects[SIZE] === 0)
+    if (graphItem.subjects[SIZE] === 0) {
       delete graphs[graph];
+      this._graphCount--;
+    }
     return true;
   }
 
@@ -827,10 +789,14 @@ export default class N3Store {
           // If only predicate and possibly object are given, the predicate index will be the fastest
           count += this._countInIndex(content.predicates, predicateId, objectId, subjectId);
         }
-        else {
-          // If only object is possibly given, the object index will be the fastest
+        else if (object) {
+          // If only object is given, the object index will be the fastest
           count += this._countInIndex(content.objects, objectId, subjectId, predicateId);
         }
+        else {
+          // Without a pattern, the subject index sums the fewest leaf counts
+          count += this._countInIndex(content.subjects);
+        }
       }
     }
     return count;
@@ -1148,13 +1114,9 @@ export default class N3Store {
 
     if (Array.isArray(quads))
       this.addQuads(quads);
-    // Index merging bypasses observer notifications
-    else if (this._observers === null && 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
-      }
-    }
+    // A store with the same entity index can be copied by identifier
+    else if (quads instanceof N3Store && quads._entityIndex === this._entityIndex)
+      this._addFromIndex(quads._graphs);
     else {
       for (const quad of quads)
         this.add(quad);
@@ -1175,19 +1137,26 @@ export default class N3Store {
     if (other === this)
       return true;
 
-    if (!(other instanceof N3Store) || this._entityIndex !== other._entityIndex)
+    if (!(other instanceof N3Store) || this._entityIndex !== other._entityIndex) {
+      // A larger set cannot be a subset, but only compare sizes that are known without counting
+      const otherSize = knownSize(other), thisSize = this._size;
+      if (otherSize !== null && thisSize !== null && otherSize > thisSize)
+        return false;
       return other.every(quad => this.has(quad));
+    }
 
+    // At every level, the index of the subset cannot have more entries
     const g1 = this._graphs, g2 = other._graphs;
-    let s1, s2, p1, p2, o1;
+    let s1, s2, p1, p2, o1, o2;
     for (const graph in g2) {
       if (!(s1 = g1[graph])) return false;
       s1 = s1.subjects;
-      for (const subject in (s2 = g2[graph].subjects)) {
-        if (!(p1 = s1[subject])) return false;
-        for (const predicate in (p2 = s2[subject])) {
-          if (!(o1 = p1[predicate])) return false;
-          for (const object in p2[predicate])
+      if ((s2 = g2[graph].subjects)[SIZE] > s1[SIZE]) return false;
+      for (const subject in s2) {
+        if (!(p1 = s1[subject]) || (p2 = s2[subject])[SIZE] > p1[SIZE]) return false;
+        for (const predicate in p2) {
+          if (!(o1 = p1[predicate]) || (o2 = p2[predicate])[SIZE] > o1[SIZE]) return false;
+          for (const object in o2)
             if (!(object in o1)) return false;
         }
       }
@@ -1224,11 +1193,7 @@ export default class N3Store {
 
     if ((other instanceof N3Store) && other._entityIndex === this._entityIndex) {
       const store = new N3Store({ entityIndex: this._entityIndex });
-      const graphs = difference(this._graphs, other._graphs);
-      if (graphs) {
-        store._graphs = graphs;
-        store._size = null;
-      }
+      store._addFromIndex(this._graphs, other._graphs);
       return store;
     }
 
@@ -1269,20 +1234,34 @@ export default class N3Store {
 
     if (other === this) {
       const store = new N3Store({ entityIndex: this._entityIndex });
-      store._graphs = merge(Object.create(null), this._graphs);
-      store._size = this._size;
+      store._addFromIndex(this._graphs);
       return store;
     }
     else if ((other instanceof N3Store) && this._entityIndex === other._entityIndex) {
       const store = new N3Store({ entityIndex: this._entityIndex });
-      const graphs = intersect(other._graphs, this._graphs);
-      if (graphs) {
-        store._graphs = graphs;
-        store._size = null;
+      // Starting a loop over no graphs costs more than checking for an empty store
+      if (this._size !== 0 && other._size !== 0) {
+        if (other._graphCount < this._graphCount)
+          store._addIntersectionFromIndex(other._graphs, this._graphs);
+        else
+          store._addIntersectionFromIndex(this._graphs, other._graphs);
       }
       return store;
     }
 
+    // Test the quads of the smaller dataset against the larger one
+    // when both sizes are known without counting
+    const otherSize = knownSize(other), thisSize = this._size;
+    if (otherSize !== null && thisSize !== null && otherSize < thisSize && typeof other[Symbol.iterator] === 'function' &&
+        // unless it is a store whose custom factories may not create RDF/JS quads,
+        // either for its quads or, through its entity index, for their terms
+        other._factory === N3DataFactory && other._entityIndex._factory === N3DataFactory) {
+      const store = new N3Store({ entityIndex: this._entityIndex });
+      for (const quad of other)
+        if (this.has(quad))
+          store.add(quad);
+      return store;
+    }
     return this.filter(quad => other.has(quad));
   }
 
@@ -1353,9 +1332,7 @@ export default class N3Store {
    */
   union(quads) {
     const store = new N3Store({ entityIndex: this._entityIndex });
-    store._graphs = merge(Object.create(null), this._graphs);
-    store._size = this._size;
-
+    store._addFromIndex(this._graphs);
     store.addAll(quads);
     return store;
   }
@@ -1620,8 +1597,10 @@ class DatasetCoreAndReadableStream extends Readable {
             objects = indexMatch(content.objects, [objectId, subjectId, predicateId]);
           }
 
-          if (subjects)
+          if (subjects) {
             newStore._graphs[graphKey] = { subjects, predicates, objects };
+            newStore._graphCount++;
+          }
         }
       }
       newStore._size = null;

package/src/N3Writer.js

@@ -10,15 +10,11 @@ const DEFAULTGRAPH = N3DataFactory.defaultGraph();
 const { rdf, xsd } = namespaces;
 const { hasOwnProperty } = Object.prototype;
 
-// 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,
+// Characters that require escaping, as in canonical N-Triples:
+// 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.
+const escape    = /[^ !#-\[\]-~\u0080-\uFFFD]/,
+    escapeAll = /[^ !#-\[\]-~\u0080-\uFFFD]/g,
     escapedCharacters = {
       '\\': '\\\\', '"': '\\"', '\t': '\\t',
       '\n': '\\n', '\r': '\\r', '\b': '\\b', '\f': '\\f',
@@ -72,7 +68,6 @@ 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;
       if (options.version)
         this._write(`@version "${options.version}".\n`);
@@ -89,9 +84,6 @@ 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;
       if (options.version)
         this._write(`VERSION "${options.version}"\n`);
     }
@@ -208,8 +200,8 @@ export default class N3Writer {
       iri = this._baseIri.toRelative(iri);
     }
     // Escape special characters
-    if (this._escape.test(iri))
-      iri = iri.replace(this._escapeAll, this._characterReplacer);
+    if (escape.test(iri))
+      iri = iri.replace(escapeAll, characterReplacer);
     // Try to represent the IRI as prefixed name, unless no prefixes were added
     const prefixMatch = this._hasPrefixes ? (this._prefixRegex || this._createPrefixRegex()).exec(iri) : null;
     return !prefixMatch ? `<${iri}>` : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
@@ -219,8 +211,8 @@ export default class N3Writer {
   _encodeLiteral(literal) {
     // Escape special characters
     let value = literal.value;
-    if (this._escape.test(value))
-      value = value.replace(this._escapeAll, this._characterReplacer);
+    if (escape.test(value))
+      value = value.replace(escapeAll, characterReplacer);
 
     // Write a language-tagged literal
     const language = literal.language;
@@ -291,13 +283,11 @@ export default class N3Writer {
 
   // ### `_encodeQuad` encodes an RDF-star quad
   _encodeQuad({ subject, predicate, object, graph }) {
-    // Canonical N-Triples and N-Quads put spaces inside the delimiters
-    const space = this._lineMode ? ' ' : '';
-    return `<<(${space}${
+    return `<<( ${
       this._encodeSubject(subject)} ${
       this._encodePredicate(predicate)} ${
       this._encodeObject(object)}${
-      isDefaultGraph(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`}${space})>>`;
+      isDefaultGraph(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`} )>>`;
   }
 
   // ### `_blockedWrite` replaces `_write` after the writer has been closed
@@ -440,27 +430,7 @@ export default class N3Writer {
 
 // Replaces a character by its escaped version
 function characterReplacer(character) {
-  // Replace a single character by its escaped version
-  let result = escapedCharacters[character];
-  if (result === undefined) {
-    // Replace a single character with its 4-bit unicode escape sequence
-    if (character.length === 1) {
-      result = character.charCodeAt(0).toString(16);
-      result = '\\u0000'.substr(0, 6 - result.length) + result;
-    }
-    // Replace a surrogate pair with its 8-bit unicode escape sequence
-    else {
-      result = ((character.charCodeAt(0) - 0xD800) * 0x400 +
-                 character.charCodeAt(1) + 0x2400).toString(16);
-      result = '\\U00000000'.substr(0, 10 - result.length) + result;
-    }
-  }
-  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) {
+  // Use a short escape where one exists, and an upper-case `\uXXXX` escape otherwise
   let result = escapedCharacters[character];
   if (result === undefined) {
     result = character.charCodeAt(0).toString(16).toUpperCase();