n3 0.4.5 → 0.5.0

package/.travis.yml

@@ -1,10 +1,7 @@
 language: node_js
 node_js:
- - "0.10"
-
-branches:
-  except:
-    - browser
-    - earl
+ - "4"
+ - "6"
+ - "node"
 
 sudo: false

package/lib/N3Store.js

@@ -11,22 +11,25 @@ function N3Store(triples, options) {
   this._size = 0;
   // `_graphs` contains subject, predicate, and object indexes per graph.
   this._graphs = Object.create(null);
-  // `_entities` maps entities such as `http://xmlns.com/foaf/0.1/name` to numbers.
-  // This saves memory, since only the numbers have to be stored in `_graphs`.
-  this._entities = Object.create(null);
-  this._entities['><'] = 0; // Dummy entry, so the first actual key is non-zero
-  this._entityCount = 0;
-  // `_blankNodeIndex` is the index of the last created blank node that was automatically named
+  // `_ids` maps entities such as `http://xmlns.com/foaf/0.1/name` to numbers,
+  // saving memory by using only numbers as keys in `_graphs`.
+  this._id = 0;
+  this._ids = Object.create(null);
+  this._ids['><'] = 0; // dummy entry, so the first actual key is non-zero
+  this._entities = Object.create(null); // inverse of `_ids`
+  // `_blankNodeIndex` is the index of the last automatically named blank node
   this._blankNodeIndex = 0;
 
   // Shift parameters if `triples` is not given
   if (!options && triples && !triples[0])
     options = triples, triples = null;
+  options = options || {};
 
   // Add triples and prefixes if passed
   this._prefixes = Object.create(null);
-  if (options && options.prefixes)
+  if (options.prefixes)
     this.addPrefixes(options.prefixes);
+  this.defaultGraph = options.defaultGraph || 'http://example.org/#defaultGraph';
   if (triples)
     this.addTriples(triples);
 }
@@ -53,12 +56,16 @@ N3Store.prototype = {
   // ## Private methods
 
   // ### `_addToIndex` adds a triple to a three-layered index.
+  // Returns if the index has changed, if the entry did not already exist.
   _addToIndex: function (index0, key0, key1, key2) {
     // Create layers as necessary.
     var index1 = index0[key0] || (index0[key0] = {});
     var index2 = index1[key1] || (index1[key1] = {});
-    // Setting the key to _any_ value signalizes the presence of the triple.
-    index2[key2] = null;
+    // Setting the key to _any_ value signals the presence of the triple.
+    var existed = key2 in index2;
+    if (!existed)
+      index2[key2] = null;
+    return !existed;
   },
 
   // ### `_removeFromIndex` removes a triple from a three-layered index.
@@ -82,7 +89,9 @@ N3Store.prototype = {
   // (for instance: _subject_, _predicate_, and _object_).
   // Finally, `graph` will be the graph of the created triples.
   _findInIndex: function (index0, key0, key1, key2, name0, name1, name2, graph) {
-    var results = [], entityKeys = Object.keys(this._entities), tmp, index1, index2;
+    var results = [], tmp, index1, index2, varCount = !key0 + !key1 + !key2,
+        // depending on the number of variables, keys or reverse index are faster
+        entityKeys = varCount > 1 ? Object.keys(this._ids) : this._entities;
 
     // If a key is specified, use only that part of index 0.
     if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];
@@ -141,6 +150,7 @@ N3Store.prototype = {
   // ## Public methods
 
   // ### `addTriple` adds a new N3 triple to the store.
+  // Returns if the triple index has changed, if the triple did not already exist.
   addTriple: function (subject, predicate, object, graph) {
     // Shift arguments if a triple object is given instead of components
     if (!predicate)
@@ -148,7 +158,7 @@ N3Store.prototype = {
         predicate = subject.predicate, subject = subject.subject;
 
     // Find the graph that will contain the triple.
-    graph = graph || '';
+    graph = graph || this.defaultGraph;
     var graphItem = this._graphs[graph];
     // Create the graph if it doesn't exist yet.
     if (!graphItem) {
@@ -161,17 +171,19 @@ N3Store.prototype = {
     // Since entities can often be long IRIs, we avoid storing them in every index.
     // Instead, we have a separate index that maps entities to numbers,
     // which are then used as keys in the other indexes.
+    var ids = this._ids;
     var entities = this._entities;
-    subject   = entities[subject]   || (entities[subject]   = ++this._entityCount);
-    predicate = entities[predicate] || (entities[predicate] = ++this._entityCount);
-    object    = entities[object]    || (entities[object]    = ++this._entityCount);
+    subject   = ids[subject]   || (ids[entities[++this._id] = subject]   = this._id);
+    predicate = ids[predicate] || (ids[entities[++this._id] = predicate] = this._id);
+    object    = ids[object]    || (ids[entities[++this._id] = object]    = this._id);
 
-    this._addToIndex(graphItem.subjects,   subject,   predicate, object);
+    var changed = this._addToIndex(graphItem.subjects,   subject,   predicate, object);
     this._addToIndex(graphItem.predicates, predicate, object,    subject);
     this._addToIndex(graphItem.objects,    object,    subject,   predicate);
 
     // The cached triple count is now invalid.
     this._size = null;
+    return changed;
   },
 
   // ### `addTriples` adds multiple N3 triples to the store.
@@ -197,20 +209,20 @@ N3Store.prototype = {
     if (!predicate)
       graph = subject.graph, object = subject.object,
         predicate = subject.predicate, subject = subject.subject;
-    graph = graph || '';
+    graph = graph || this.defaultGraph;
 
     // Find internal identifiers for all components.
-    var graphItem, entities = this._entities, graphs = this._graphs;
-    if (!(subject     = entities[subject]))   return;
-    if (!(predicate   = entities[predicate])) return;
-    if (!(object      = entities[object]))    return;
-    if (!(graphItem   = graphs[graph]))       return;
+    var graphItem, ids = this._ids, graphs = this._graphs;
+    if (!(subject     = ids[subject]))   return false;
+    if (!(predicate   = ids[predicate])) return false;
+    if (!(object      = ids[object]))    return false;
+    if (!(graphItem   = graphs[graph]))       return false;
 
     // Verify that the triple exists.
     var subjects, predicates;
-    if (!(subjects   = graphItem.subjects[subject])) return;
-    if (!(predicates = subjects[predicate])) return;
-    if (!(object in predicates)) return;
+    if (!(subjects   = graphItem.subjects[subject])) return false;
+    if (!(predicates = subjects[predicate])) return false;
+    if (!(object in predicates)) return false;
 
     // Remove it from all indexes.
     this._removeFromIndex(graphItem.subjects,   subject,   predicate, object);
@@ -219,8 +231,9 @@ N3Store.prototype = {
     if (this._size !== null) this._size--;
 
     // Remove the graph if it is empty.
-    for (subject in graphItem.subjects) return;
+    for (subject in graphItem.subjects) return true;
     delete graphs[graph];
+    return true;
   },
 
   // ### `removeTriples` removes multiple N3 triples from the store.
@@ -230,8 +243,7 @@ N3Store.prototype = {
   },
 
   // ### `find` finds a set of triples matching a pattern, expanding prefixes as necessary.
-  // Setting `subject`, `predicate`, or `object` to `null` means an _anything_ wildcard.
-  // Setting `graph` to `null` means the default graph.
+  // Setting `subject`, `predicate`, `object` or `graph` to a falsy value means an _anything_ wildcard.
   find: function (subject, predicate, object, graph) {
     var prefixes = this._prefixes;
     return this.findByIRI(
@@ -243,44 +255,51 @@ N3Store.prototype = {
   },
 
   // ### `findByIRI` finds a set of triples matching a pattern.
-  // Setting `subject`, `predicate`, or `object` to a falsy value means an _anything_ wildcard.
-  // Setting `graph` to a falsy value means the default graph.
+  // Setting `subject`, `predicate`, `object` or `graph` to a falsy value means an _anything_ wildcard.
   findByIRI: function (subject, predicate, object, graph) {
-    graph = graph || '';
-    var graphItem = this._graphs[graph], entities = this._entities;
-
-    // If the specified graph contain no triples, there are no results.
-    if (!graphItem) return [];
-
-    // Translate IRIs to internal index keys.
-    // Optimization: if the entity doesn't exist, no triples with it exist.
-    if (subject   && !(subject   = entities[subject]))   return [];
-    if (predicate && !(predicate = entities[predicate])) return [];
-    if (object    && !(object    = entities[object]))    return [];
-
-    // Choose the optimal index, based on what fields are present
-    if (subject) {
-      if (object)
-        // If subject and object are given, the object index will be the fastest.
-        return this._findInIndex(graphItem.objects, object, subject, predicate,
-                                 'object', 'subject', 'predicate', graph);
-      else
-        // If only subject and possibly predicate are given, the subject index will be the fastest.
-        return this._findInIndex(graphItem.subjects, subject, predicate, null,
-                                 'subject', 'predicate', 'object', graph);
-    }
-    else if (predicate)
-      // If only predicate and possibly object are given, the predicate index will be the fastest.
-      return this._findInIndex(graphItem.predicates, predicate, object, null,
-                               'predicate', 'object', 'subject', graph);
-    else if (object)
-      // If only object is given, the object index will be the fastest.
-      return this._findInIndex(graphItem.objects, object, null, null,
-                               'object', 'subject', 'predicate', graph);
+    var quads = [], graphs = {}, graphContents,
+        ids = this._ids, subjectId, predicateId, objectId;
+    // Either loop over all graphs, or over just one selected graph.
+    if (!graph)
+      graphs = this._graphs;
     else
-      // If nothing is given, iterate subjects and predicates first
-      return this._findInIndex(graphItem.subjects, null, null, null,
-                               'subject', 'predicate', 'object', graph);
+      graphs[graph] = this._graphs[graph];
+
+    for (var graphId in graphs) {
+      // Only if the specified graph contains triples, there can be results
+      if (graphContents = graphs[graphId]) {
+        // Translate IRIs to internal index keys.
+        // Optimization: if the entity doesn't exist, no triples with it exist.
+        if (subject   && !(subjectId   = ids[subject]))   return quads;
+        if (predicate && !(predicateId = ids[predicate])) return quads;
+        if (object    && !(objectId    = ids[object]))    return quads;
+
+        // Choose the optimal index, based on what fields are present
+        if (subjectId) {
+          if (objectId)
+          // If subject and object are given, the object index will be the fastest.
+            quads.push(this._findInIndex(graphContents.objects, objectId, subjectId, predicateId,
+                                         'object', 'subject', 'predicate', graphId));
+          else
+          // If only subject and possibly predicate are given, the subject index will be the fastest.
+            quads.push(this._findInIndex(graphContents.subjects, subjectId, predicateId, null,
+                                         'subject', 'predicate', 'object', graphId));
+        }
+        else if (predicateId)
+        // If only predicate and possibly object are given, the predicate index will be the fastest.
+          quads.push(this._findInIndex(graphContents.predicates, predicateId, objectId, null,
+                                       'predicate', 'object', 'subject', graphId));
+        else if (objectId)
+        // If only object is given, the object index will be the fastest.
+          quads.push(this._findInIndex(graphContents.objects, objectId, null, null,
+                                       'object', 'subject', 'predicate', graphId));
+        else
+        // If nothing is given, iterate subjects and predicates first
+          quads.push(this._findInIndex(graphContents.subjects, null, null, null,
+                                       'subject', 'predicate', 'object', graphId));
+      }
+    }
+    return quads.length === 1 ? quads[0] : quads.concat.apply([], quads);
   },
 
   // ### `count` returns the number of triples matching a pattern, expanding prefixes as necessary.
@@ -300,17 +319,17 @@ N3Store.prototype = {
   // Setting `subject`, `predicate`, or `object` to `null` means an _anything_ wildcard.
   // Setting `graph` to `null` means the default graph.
   countByIRI: function (subject, predicate, object, graph) {
-    graph = graph || '';
-    var graphItem = this._graphs[graph], entities = this._entities;
+    graph = graph || this.defaultGraph;
+    var graphItem = this._graphs[graph], ids = this._ids;
 
     // If the specified graph contain no triples, there are no results.
     if (!graphItem) return 0;
 
     // Translate IRIs to internal index keys.
     // Optimization: if the entity doesn't exist, no triples with it exist.
-    if (subject   && !(subject   = entities[subject]))   return 0;
-    if (predicate && !(predicate = entities[predicate])) return 0;
-    if (object    && !(object    = entities[object]))    return 0;
+    if (subject   && !(subject   = ids[subject]))   return 0;
+    if (predicate && !(predicate = ids[predicate])) return 0;
+    if (object    && !(object    = ids[object]))    return 0;
 
     // Choose the optimal index, based on what fields are present
     if (subject) {
@@ -337,16 +356,16 @@ N3Store.prototype = {
     // Generate a name based on the suggested name
     if (suggestedName) {
       name = suggestedName = '_:' + suggestedName, index = 1;
-      while (this._entities[name])
+      while (this._ids[name])
         name = suggestedName + index++;
     }
     // Generate a generic blank node name
     else {
       do { name = '_:b' + this._blankNodeIndex++; }
-      while (this._entities[name]);
+      while (this._ids[name]);
     }
     // Add the blank node to the entities, avoiding the generation of duplicates
-    this._entities[name] = ++this._entityCount;
+    this._ids[name] = ++this._id;
     return name;
   },
 };

package/lib/N3Util.js

@@ -94,6 +94,35 @@ var N3Util = {
            (/^[a-z]+(-[a-z0-9]+)*$/i.test(modifier) ? '"@'  + modifier.toLowerCase()
                                                     : '"^^' + modifier);
   },
+
+  // Creates a function that prepends the given IRI to a local name
+  prefix: function (iri) {
+    return N3Util.prefixes({ '': iri })('');
+  },
+
+  // Creates a function that allows registering and expanding prefixes
+  prefixes: function (defaultPrefixes) {
+    // Add all of the default prefixes
+    var prefixes = Object.create(null);
+    for (var prefix in defaultPrefixes)
+      processPrefix(prefix, defaultPrefixes[prefix]);
+
+    // Registers a new prefix (if an IRI was specified)
+    // or retrieves a function that expands an existing prefix (if no IRI was specified)
+    function processPrefix(prefix, iri) {
+      // Create a new prefix if an IRI is specified or the prefix doesn't exist
+      if (iri || !(prefix in prefixes)) {
+        var cache = Object.create(null);
+        iri = iri || '';
+        // Create a function that expands the prefix
+        prefixes[prefix] = function (localName) {
+          return cache[localName] || (cache[localName] = iri + localName);
+        };
+      }
+      return prefixes[prefix];
+    }
+    return processPrefix;
+  },
 };
 
 // Add the N3Util functions to the given object or its prototype

package/package.json

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

package/perf/N3Store-perf.js

@@ -4,26 +4,48 @@ var assert = require('assert');
 
 console.log('N3Store performance test');
 
-var TEST;
-var dim = parseInt(process.argv[2], 10) || 256;
-var dimSquared = dim * dim;
-var dimCubed = dimSquared * dim;
 var prefix = 'http://example.org/#';
+var TEST, dim, dimSquared, dimCubed, dimQuads, store;
 
-var store = new N3.Store();
+/* Test triples */
+dim = parseInt(process.argv[2], 10) || 256;
+dimSquared = dim * dim;
+dimCubed = dimSquared * dim;
 
-TEST = '- Adding ' + dimCubed + ' triples';
+store = new N3.Store();
+TEST = '- Adding ' + dimCubed + ' triples in the default graph';
 console.time(TEST);
-var i, j, k;
+var i, j, k, l;
 for (i = 0; i < dim; i++)
   for (j = 0; j < dim; j++)
     for (k = 0; k < dim; k++)
       store.addTriple(prefix + i, prefix + j, prefix + k);
 console.timeEnd(TEST);
 
-console.log('* Memory usage: ' + Math.round(process.memoryUsage().rss / 1024 / 1024) + 'MB');
+console.log('* Memory usage for triples: ' + Math.round(process.memoryUsage().rss / 1024 / 1024) + 'MB');
 
-TEST = '- Finding all ' + dimCubed + ' triples ' + dimSquared * 3 + ' times';
+TEST = '- Finding all ' + dimCubed + ' triples to the default graph ' + dimSquared * 1 + ' times (0 variables)';
+console.time(TEST);
+for (i = 0; i < dim; i++)
+  for (j = 0; j < dim; j++)
+    for (k = 0; k < dim; k++)
+      assert.equal(store.find(prefix + i, prefix + j, prefix + k).length, 1);
+console.timeEnd(TEST);
+
+TEST = '- Finding all ' + dimCubed + ' triples to the default graph ' + dimSquared * 2 + ' times (1 variable)';
+console.time(TEST);
+for (i = 0; i < dim; i++)
+  for (j = 0; j < dim; j++)
+    assert.equal(store.find(prefix + i, prefix + j, null).length, dim);
+for (i = 0; i < dim; i++)
+  for (j = 0; j < dim; j++)
+    assert.equal(store.find(prefix + i, null, prefix + j).length, dim);
+for (i = 0; i < dim; i++)
+  for (j = 0; j < dim; j++)
+    assert.equal(store.find(null, prefix + i, prefix + j).length, dim);
+console.timeEnd(TEST);
+
+TEST = '- Finding all ' + dimCubed + ' triples to the default graph ' + dimSquared * 3 + ' times (2 variables)';
 console.time(TEST);
 for (i = 0; i < dim; i++)
   assert.equal(store.find(prefix + i, null, null).length, dimSquared);
@@ -32,3 +54,35 @@ for (j = 0; j < dim; j++)
 for (k = 0; k < dim; k++)
   assert.equal(store.find(null, null, prefix + k).length, dimSquared);
 console.timeEnd(TEST);
+
+console.log();
+
+/* Test quads */
+dim /= 4,
+dimSquared = dim * dim;
+dimCubed = dimSquared * dim;
+dimQuads = dimCubed * dim;
+
+store = new N3.Store();
+TEST = '- Adding ' + dimQuads + ' quads';
+console.time(TEST);
+for (i = 0; i < dim; i++)
+  for (j = 0; j < dim; j++)
+    for (k = 0; k < dim; k++)
+      for (l = 0; l < dim; l++)
+        store.addTriple(prefix + i, prefix + j, prefix + k, prefix + l);
+console.timeEnd(TEST);
+
+console.log('* Memory usage for quads: ' + Math.round(process.memoryUsage().rss / 1024 / 1024) + 'MB');
+
+TEST = '- Finding all ' + dimQuads + ' quads ' + dimCubed * 4 + ' times';
+console.time(TEST);
+for (i = 0; i < dim; i++)
+  assert.equal(store.find(prefix + i, null, null, null).length, dimCubed);
+for (j = 0; j < dim; j++)
+  assert.equal(store.find(null, prefix + j, null, null).length, dimCubed);
+for (k = 0; k < dim; k++)
+  assert.equal(store.find(null, null, prefix + k, null).length, dimCubed);
+for (l = 0; l < dim; l++)
+  assert.equal(store.find(null, null, null, prefix + l).length, dimCubed);
+console.timeEnd(TEST);

package/spec/trig/LICENSE

@@ -0,0 +1,48 @@
+Summary
+=======
+
+Distributed under both the W3C Test Suite License[1] and the W3C 3-clause BSD License[2]. To contribute to a W3C Test Suite, see the policies and contribution forms [3]
+
+1. http://www.w3.org/Consortium/Legal/2008/04-testsuite-license
+2. http://www.w3.org/Consortium/Legal/2008/03-bsd-license
+3. http://www.w3.org/2004/10/27-testcases
+
+DISCLAIMER
+
+UNDER BOTH MUTUALLY EXCLUSIVE LICENSES, THIS DOCUMENT AND ALL DOCUMENTS, TESTS AND SOFTWARE THAT LINK THIS STATEMENT ARE PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
+COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF.
+
+
+W3C Test Suite License
+======================
+
+This document, Test Suites and other documents that link to this statement are provided by the copyright holders under the following license: By using and/or copying this document, or the W3C document from which this statement is linked, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions:
+
+Permission to copy, and distribute the contents of this document, or the W3C document from which this statement is linked, in any medium for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the document, or portions thereof, that you use:
+
+A link or URL to the original W3C document.
+The pre-existing copyright notice of the original author, or if it doesn't exist, a notice (hypertext is preferred, but a textual representation is permitted) of the form: "Copyright © [$date-of-document] World Wide Web Consortium, (Massachusetts Institute of Technology, European Research Consortium for Informatics and Mathematics, Keio University) and others. All Rights Reserved. http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html"
+If it exists, the STATUS of the W3C document.
+When space permits, inclusion of the full text of this NOTICE should be provided. We request that authorship attribution be provided in any software, documents, or other items or products that you create pursuant to the implementation of the contents of this document, or any portion thereof.
+
+No right to create modifications or derivatives of W3C documents is granted pursuant to this license. However, if additional requirements (documented in the Copyright FAQ) are satisfied, the right to create modifications or derivatives is sometimes granted by the W3C to individuals complying with those requirements.
+
+If a Test Suite distinguishes the test harness (or, framework for navigation) and the actual tests, permission is given to remove or alter the harness or navigation if the Test Suite in question allows to do so. The tests themselves shall NOT be changed in any way.
+
+The name and trademarks of W3C and other copyright holders may NOT be used in advertising or publicity pertaining to this document or other documents that link to this statement without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders. Permission is given to use the trademarked string W3C within claims of performance concerning W3C Specifications or features described therein, and there only, if the test suite so authorizes.
+
+THIS WORK IS PROVIDED BY W3C, MIT, ERCIM, KEIO UNIVERSITY, THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL W3C, MIT, ERCIM, KEIO UNIVERSITY, THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+W3C 3-clause BSD License
+========================
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+	Redistributions of works must retain the original copyright notice, this list of conditions and the following disclaimer.
+
+	Redistributions in binary form must reproduce the original copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+	Neither the name of the W3C nor the names of its contributors may be used to endorse or promote products derived from this work without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/spec/turtle/LICENSE

@@ -0,0 +1,117 @@
+Summary
+=======
+
+Distributed under both the W3C Test Suite License[1] and the W3C 3-clause BSD
+License[2]. To contribute to a W3C Test Suite, see the policies and contribution
+forms [3]
+
+1. http://www.w3.org/Consortium/Legal/2008/04-testsuite-license
+2. http://www.w3.org/Consortium/Legal/2008/03-bsd-license
+3. http://www.w3.org/2004/10/27-testcases
+
+DISCLAIMER
+
+UNDER BOTH MUTUALLY EXCLUSIVE LICENSES, THIS DOCUMENT AND ALL DOCUMENTS, TESTS
+AND SOFTWARE THAT LINK THIS STATEMENT ARE PROVIDED "AS IS," AND COPYRIGHT
+HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING,
+BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE
+SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT
+INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
+COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE
+OR IMPLEMENTATION OF THE CONTENTS THEREOF.
+
+
+W3C Test Suite License
+======================
+
+This document, Test Suites and other documents that link to this statement are
+provided by the copyright holders under the following license: By using and/or
+copying this document, or the W3C document from which this statement is linked,
+you (the licensee) agree that you have read, understood, and will comply with
+the following terms and conditions:
+
+Permission to copy, and distribute the contents of this document, or the W3C
+document from which this statement is linked, in any medium for any purpose and
+without fee or royalty is hereby granted, provided that you include the
+following on ALL copies of the document, or portions thereof, that you use:
+
+1 A link or URL to the original W3C document.
+
+2 The pre-existing copyright notice of the original author, or if it doesn't
+  exist, a notice (hypertext is preferred, but a textual representation is
+  permitted) of the form: "Copyright © [$date-of-document] World Wide Web
+  Consortium, (Massachusetts Institute of Technology, European Research
+  Consortium for Informatics and Mathematics, Keio University) and others. All
+  Rights
+  Reserved. http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html"
+
+3 If it exists, the STATUS of the W3C document.
+
+4 When space permits, inclusion of the full text of this NOTICE should be
+  provided. We request that authorship attribution be provided in any software,
+  documents, or other items or products that you create pursuant to the
+  implementation of the contents of this document, or any portion thereof.
+
+
+No right to create modifications or derivatives of W3C documents is granted
+pursuant to this license. However, if additional requirements (documented in the
+Copyright FAQ) are satisfied, the right to create modifications or derivatives
+is sometimes granted by the W3C to individuals complying with those
+requirements.
+
+If a Test Suite distinguishes the test harness (or, framework for navigation)
+and the actual tests, permission is given to remove or alter the harness or
+navigation if the Test Suite in question allows to do so. The tests themselves
+shall NOT be changed in any way.
+
+The name and trademarks of W3C and other copyright holders may NOT be used in
+advertising or publicity pertaining to this document or other documents that
+link to this statement without specific, written prior permission. Title to
+copyright in this document will at all times remain with copyright
+holders. Permission is given to use the trademarked string W3C within claims of
+performance concerning W3C Specifications or features described therein, and
+there only, if the test suite so authorizes.
+
+THIS WORK IS PROVIDED BY W3C, MIT, ERCIM, KEIO UNIVERSITY, THE COPYRIGHT HOLDERS
+AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
+NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL W3C, MIT, ERCIM, KEIO
+UNIVERSITY, THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+W3C 3-clause BSD License
+========================
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1 Redistributions of works must retain the original copyright notice, this list
+  of conditions and the following disclaimer.
+
+2 Redistributions in binary form must reproduce the original copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+3 Neither the name of the W3C nor the names of its contributors may be used to
+  endorse or promote products derived from this work without specific prior
+  written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/test/N3Store-test.js

@@ -34,7 +34,7 @@ describe('N3Store', function () {
       store.createBlankNode().should.eql('_:b0');
       store.createBlankNode().should.eql('_:b1');
 
-      store.addTriple('_:b0', '_:b1', '_:b2');
+      store.addTriple('_:b0', '_:b1', '_:b2').should.be.true;
       store.createBlankNode().should.eql('_:b3');
     });
 
@@ -45,11 +45,28 @@ describe('N3Store', function () {
     });
 
     it('should be able to store triples with generated blank nodes', function () {
-      store.addTriple(store.createBlankNode('x'), 'b', 'c');
+      store.addTriple(store.createBlankNode('x'), 'b', 'c').should.be.true;
       shouldIncludeAll(store.find(null, 'b'), ['_:x1', 'b', 'd']);
     });
   });
 
+  describe('An N3Store without a configured default graph', function () {
+    var store = new N3Store();
+
+    it('should have a dummy default graph', function () {
+      store.defaultGraph.should.eql('http://example.org/#defaultGraph');
+    });
+  });
+
+  describe('An N3Store with a configured default graph', function () {
+    var dg = 'http://example.org/#defaultGraph';
+    var store = new N3Store({ defaultGraph: dg });
+
+    it('should return that configured default graph', function () {
+      store.defaultGraph.should.eql(dg);
+    });
+  });
+
   describe('An N3Store with initialized with 3 elements', function () {
     var store = new N3Store([
       { subject: 's1', predicate: 'p1', object: 'o1' },
@@ -60,32 +77,79 @@ describe('N3Store', function () {
     it('should have size 3', function () {
       store.size.should.eql(3);
     });
+
+    describe('adding a triple that already exists', function () {
+      it('should return false', function () {
+        store.addTriple('s1', 'p1', 'o1').should.be.false;
+      });
+
+      it('should not increase the size', function () {
+        store.size.should.eql(3);
+      });
+    });
+
+    describe('adding a triple that did not exist yet', function () {
+      it('should return true', function () {
+        store.addTriple('s1', 'p1', 'o4').should.be.true;
+      });
+
+      it('should increase the size', function () {
+        store.size.should.eql(4);
+      });
+    });
+
+    describe('removing an existing triple', function () {
+      it('should return true', function () {
+        store.removeTriple('s1', 'p1', 'o4').should.be.true;
+      });
+
+      it('should decrease the size', function () {
+        store.size.should.eql(3);
+      });
+    });
+
+    describe('removing a non-existing triple', function () {
+      it('should return false', function () {
+        store.removeTriple('s1', 'p1', 'o5').should.be.false;
+      });
+
+      it('should not decrease the size', function () {
+        store.size.should.eql(3);
+      });
+    });
   });
 
   describe('An N3Store with 5 elements', function () {
-    var store = new N3Store();
-    store.addTriple('s1', 'p1', 'o1');
-    store.addTriple({ subject: 's1', predicate: 'p1', object: 'o2' });
+    var store = new N3Store({ defaultGraph: 'http://example.org/#defaultGraph' });
+    store.addTriple('s1', 'p1', 'o1').should.be.true;
+    store.addTriple({ subject: 's1', predicate: 'p1', object: 'o2' }).should.be.true;
     store.addTriples([
       { subject: 's1', predicate: 'p2', object: 'o2' },
       { subject: 's2', predicate: 'p1', object: 'o1' },
     ]);
-    store.addTriple('s1', 'p2', 'o3', 'c4');
+    store.addTriple('s1', 'p2', 'o3', 'c4').should.be.true;
 
     it('should have size 5', function () {
       store.size.should.eql(5);
     });
 
     describe('when searched without parameters', function () {
-      it('should return all items in the default graph',
+      it('should return all items',
         shouldIncludeAll(store.find(),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2'], ['s2', 'p1', 'o1']));
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p2', 'o3', 'c4']));
     });
 
     describe('when searched with an existing subject parameter', function () {
-      it('should return all items with this subject in the default graph',
+      it('should return all items with this subject in all graphs',
         shouldIncludeAll(store.find('s1', null, null),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2']));
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o3', 'c4']));
     });
 
     describe('when searched with a non-existing subject parameter', function () {
@@ -99,7 +163,9 @@ describe('N3Store', function () {
     describe('when searched with an existing predicate parameter', function () {
       it('should return all items with this predicate in the default graph',
         shouldIncludeAll(store.find(null, 'p1', null),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s2', 'p1', 'o1']));
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with a non-existing predicate parameter', function () {
@@ -108,7 +174,9 @@ describe('N3Store', function () {
 
     describe('when searched with an existing object parameter', function () {
       it('should return all items with this object in the default graph',
-        shouldIncludeAll(store.find(null, null, 'o1'), ['s1', 'p1', 'o1'], ['s2', 'p1', 'o1']));
+        shouldIncludeAll(store.find(null, null, 'o1'),
+            ['s1', 'p1', 'o1', store.defaultGraph],
+            ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with a non-existing object parameter', function () {
@@ -117,7 +185,9 @@ describe('N3Store', function () {
 
     describe('when searched with existing subject and predicate parameters', function () {
       it('should return all items with this subject and predicate in the default graph',
-        shouldIncludeAll(store.find('s1', 'p1', null), ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2']));
+        shouldIncludeAll(store.find('s1', 'p1', null),
+            ['s1', 'p1', 'o1', store.defaultGraph],
+            ['s1', 'p1', 'o2', store.defaultGraph]));
     });
 
     describe('when searched with non-existing subject and predicate parameters', function () {
@@ -126,7 +196,9 @@ describe('N3Store', function () {
 
     describe('when searched with existing subject and object parameters', function () {
       it('should return all items with this subject and object in the default graph',
-        shouldIncludeAll(store.find('s1', null, 'o2'), ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2']));
+        shouldIncludeAll(store.find('s1', null, 'o2'),
+            ['s1', 'p1', 'o2', store.defaultGraph],
+            ['s1', 'p2', 'o2', store.defaultGraph]));
     });
 
     describe('when searched with non-existing subject and object parameters', function () {
@@ -135,16 +207,18 @@ describe('N3Store', function () {
 
     describe('when searched with existing predicate and object parameters', function () {
       it('should return all items with this predicate and object in the default graph',
-        shouldIncludeAll(store.find(null, 'p1', 'o1'), ['s1', 'p1', 'o1'], ['s2', 'p1', 'o1']));
+        shouldIncludeAll(store.find(null, 'p1', 'o1'),
+            ['s1', 'p1', 'o1', store.defaultGraph],
+            ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
-    describe('when searched with non-existing predicate and object parameters', function () {
-      itShouldBeEmpty(store.find(null, 'p2', 'o3'));
+    describe('when searched with non-existing predicate and object parameters in the default graph', function () {
+      itShouldBeEmpty(store.find(null, 'p2', 'o3', store.defaultGraph));
     });
 
     describe('when searched with existing subject, predicate, and object parameters', function () {
       it('should return all items with this subject, predicate, and object in the default graph',
-        shouldIncludeAll(store.find('s1', 'p1', 'o1'), ['s1', 'p1', 'o1']));
+        shouldIncludeAll(store.find('s1', 'p1', 'o1'), ['s1', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with a non-existing triple', function () {
@@ -153,8 +227,11 @@ describe('N3Store', function () {
 
     describe('when searched with the default graph parameter', function () {
       it('should return all items in the default graph',
-        shouldIncludeAll(store.find(),
-                         ['s1', 'p1', 'o1'], ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2'], ['s2', 'p1', 'o1']));
+        shouldIncludeAll(store.find(null, null, null, store.defaultGraph),
+                         ['s1', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph]));
     });
 
     describe('when searched with an existing non-default graph parameter', function () {
@@ -281,62 +358,65 @@ describe('N3Store', function () {
     });
 
     describe('when trying to remove a triple with a non-existing subject', function () {
-      before(function () { store.removeTriple('s0', 'p1', 'o1'); });
+      before(function () { store.removeTriple('s0', 'p1', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple with a non-existing predicate', function () {
-      before(function () { store.removeTriple('s1', 'p0', 'o1'); });
+      before(function () { store.removeTriple('s1', 'p0', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple with a non-existing object', function () {
-      before(function () { store.removeTriple('s1', 'p1', 'o0'); });
+      before(function () { store.removeTriple('s1', 'p1', 'o0').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple for which no subjects exist', function () {
-      before(function () { store.removeTriple('o1', 'p1', 'o1'); });
+      before(function () { store.removeTriple('o1', 'p1', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple for which no predicates exist', function () {
-      before(function () { store.removeTriple('s1', 's1', 'o1'); });
+      before(function () { store.removeTriple('s1', 's1', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple for which no objects exist', function () {
-      before(function () { store.removeTriple('s1', 'p1', 's1'); });
+      before(function () { store.removeTriple('s1', 'p1', 's1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple that does not exist', function () {
-      before(function () { store.removeTriple('s1', 'p2', 'o1'); });
+      before(function () { store.removeTriple('s1', 'p2', 'o1').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove an incomplete triple', function () {
-      before(function () { store.removeTriple('s1', null, null); });
+      before(function () { store.removeTriple('s1', null, null).should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when trying to remove a triple with a non-existing graph', function () {
-      before(function () { store.removeTriple('s1', 'p1', 'o1', 'c0'); });
+      before(function () { store.removeTriple('s1', 'p1', 'o1', 'c0').should.be.false; });
       it('should still have size 5', function () { store.size.should.eql(5); });
     });
 
     describe('when removing an existing triple', function () {
-      before(function () { store.removeTriple('s1', 'p1', 'o1'); });
+      before(function () { store.removeTriple('s1', 'p1', 'o1').should.be.true; });
 
       it('should have size 4', function () { store.size.should.eql(4); });
 
       it('should not contain that triple anymore',
         shouldIncludeAll(function () { return store.find(); },
-                         ['s1', 'p1', 'o2'], ['s1', 'p2', 'o2'], ['s2', 'p1', 'o1']));
+                         ['s1', 'p1', 'o2', store.defaultGraph],
+                         ['s1', 'p2', 'o2', store.defaultGraph],
+                         ['s2', 'p1', 'o1', store.defaultGraph],
+                         ['s1', 'p2', 'o3', 'c4', store.defaultGraph]));
     });
 
     describe('when removing an existing triple from a non-default graph', function () {
-      before(function () { store.removeTriple('s1', 'p2', 'o3', 'c4'); });
+      before(function () { store.removeTriple('s1', 'p2', 'o3', 'c4').should.be.true; });
 
       it('should have size 3', function () { store.size.should.eql(3); });
 
@@ -355,13 +435,13 @@ describe('N3Store', function () {
 
       it('should not contain those triples anymore',
         shouldIncludeAll(function () { return store.find(); },
-                         ['s1', 'p1', 'o2']));
+                         ['s1', 'p1', 'o2', store.defaultGraph]));
     });
 
     describe('when adding and removing a triple', function () {
       before(function () {
-        store.addTriple('a', 'b', 'c');
-        store.removeTriple('a', 'b', 'c');
+        store.addTriple('a', 'b', 'c').should.be.true;
+        store.removeTriple('a', 'b', 'c').should.be.true;
       });
 
       it('should have an unchanged size', function () { store.size.should.eql(1); });
@@ -380,29 +460,39 @@ describe('N3Store', function () {
 
     describe('should allow to query subjects with prefixes', function () {
       it('should return all triples with that subject',
-        shouldIncludeAll(store.find('a:s1', null, null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+          shouldIncludeAll(store.find('a:s1', null, null),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+    });
+
+    describe('should allow to query subjects with prefixes', function () {
+      it('should return all triples with that subject in the default graph',
+          shouldIncludeAll(store.find('a:s1', null, null, store.defaultGraph),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
     });
 
     describe('should allow to query predicates with prefixes', function () {
       it('should return all triples with that predicate',
         shouldIncludeAll(store.find(null, 'b:p1', null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
     });
 
     describe('should allow to query objects with prefixes', function () {
       it('should return all triples with that object',
         shouldIncludeAll(store.find(null, null, 'a:o1'),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
     });
 
     describe('should allow to query graphs with prefixes', function () {
       it('should return all triples with that graph',
         shouldIncludeAll(store.find(null, null, null, 'http://graphs.org/#g1'),
-          ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+          ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1', store.defaultGraph]));
     });
   });
 
@@ -417,25 +507,49 @@ describe('N3Store', function () {
     store.addPrefix('a', 'http://foo.org/#');
     store.addPrefixes({ b: 'http://bar.org/', g: 'http://graphs.org/#' });
 
+    describe('should allow to query subjects with prefixes', function () {
+      it('should return all triples with that subject in the default graph',
+        shouldIncludeAll(store.find('a:s1', null, null, store.defaultGraph),
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
+    });
+
     describe('should allow to query subjects with prefixes', function () {
       it('should return all triples with that subject',
-        shouldIncludeAll(store.find('a:s1', null, null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+          shouldIncludeAll(store.find('a:s1', null, null),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+    });
+
+    describe('should allow to query predicates with prefixes', function () {
+      it('should return all triples with that predicate in the default graph',
+          shouldIncludeAll(store.find(null, 'b:p1', null, store.defaultGraph),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2', store.defaultGraph]));
     });
 
     describe('should allow to query predicates with prefixes', function () {
       it('should return all triples with that predicate',
-        shouldIncludeAll(store.find(null, 'b:p1', null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2']));
+          shouldIncludeAll(store.find(null, 'b:p1', null),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s2', 'http://bar.org/p1', 'http://foo.org/#o2', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
+    });
+
+    describe('should allow to query objects with prefixes', function () {
+      it('should return all triples with that object in the default graph',
+          shouldIncludeAll(store.find(null, null, 'a:o1', store.defaultGraph),
+              ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+              ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
     });
 
     describe('should allow to query objects with prefixes', function () {
       it('should return all triples with that object',
         shouldIncludeAll(store.find(null, null, 'a:o1'),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', 'http://graphs.org/#g1']));
     });
 
     describe('should allow to query graphs with prefixes', function () {
@@ -456,19 +570,19 @@ describe('N3Store', function () {
     describe('should allow to query subjects without prefixes', function () {
       it('should return all triples with that subject',
         shouldIncludeAll(store.find('http://foo.org/#s1', null, null),
-                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1'],
-                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1']));
+                         ['http://foo.org/#s1', 'http://bar.org/p1', 'http://foo.org/#o1', store.defaultGraph],
+                         ['http://foo.org/#s1', 'http://bar.org/p2', 'http://foo.org/#o1', store.defaultGraph]));
     });
   });
 
   describe('An N3Store created without triples but with prefixes', function () {
     var store = new N3Store({ prefixes: { http: 'http://www.w3.org/2006/http#' } });
-    store.addTriple('a', 'http://www.w3.org/2006/http#b', 'c');
+    store.addTriple('a', 'http://www.w3.org/2006/http#b', 'c').should.be.true;
 
     describe('should allow to query predicates with prefixes', function () {
       it('should return all triples with that predicate',
         shouldIncludeAll(store.find(null, 'http:b', null),
-                         ['a', 'http://www.w3.org/2006/http#b', 'c']));
+                         ['a', 'http://www.w3.org/2006/http#b', 'c', store.defaultGraph]));
     });
   });
 
@@ -478,13 +592,13 @@ describe('N3Store', function () {
     // Test inspired by http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/.
     // The value `__proto__` is not supported however – fixing it introduces too much overhead.
     it('should be able to contain entities with JavaScript object property names', function () {
-      store.addTriple('toString', 'valueOf', 'toLocaleString', 'hasOwnProperty');
+      store.addTriple('toString', 'valueOf', 'toLocaleString', 'hasOwnProperty').should.be.true;
       shouldIncludeAll(store.find(null, null, null, 'hasOwnProperty'),
                        ['toString', 'valueOf', 'toLocaleString', 'hasOwnProperty'])();
     });
 
     it('should be able to contain entities named "null"', function () {
-      store.addTriple('null', 'null', 'null', 'null');
+      store.addTriple('null', 'null', 'null', 'null').should.be.true;
       shouldIncludeAll(store.find(null, null, null, 'null'), ['null', 'null', 'null', 'null'])();
     });
   });

package/test/N3Util-test.js

@@ -340,4 +340,70 @@ describe('N3Util', function () {
       N3Util.createLiteral(true).should.equal('"true"^^http://www.w3.org/2001/XMLSchema#boolean');
     });
   });
+
+  describe('prefix', function () {
+    var baz = N3Util.prefix('http://ex.org/baz#');
+    it('should return a function', function () {
+      expect(baz).to.be.an.instanceof(Function);
+    });
+
+    describe('the function', function () {
+      it('should expand the prefix', function () {
+        expect(baz('bar')).to.equal('http://ex.org/baz#bar');
+      });
+    });
+  });
+
+  describe('prefixes', function () {
+    describe('called without arguments', function () {
+      var prefixes = N3Util.prefixes();
+      it('should return a function', function () {
+        expect(prefixes).to.be.an.instanceof(Function);
+      });
+
+      describe('the function', function () {
+        it('should not expand non-registered prefixes', function () {
+          expect(prefixes('baz')('bar')).to.equal('bar');
+        });
+
+        it('should allow registering prefixes', function () {
+          var p = prefixes('baz', 'http://ex.org/baz#');
+          expect(p).to.exist;
+          expect(p).to.equal(prefixes('baz'));
+        });
+
+        it('should expand the newly registered prefix', function () {
+          expect(prefixes('baz')('bar')).to.equal('http://ex.org/baz#bar');
+        });
+      });
+    });
+
+    describe('called with a hash of prefixes', function () {
+      var prefixes = N3Util.prefixes({ foo: 'http://ex.org/foo#', bar: 'http://ex.org/bar#' });
+      it('should return a function', function () {
+        expect(prefixes).to.be.an.instanceof(Function);
+      });
+
+      describe('the function', function () {
+        it('should expand registered prefixes', function () {
+          expect(prefixes('foo')('bar')).to.equal('http://ex.org/foo#bar');
+          expect(prefixes('bar')('bar')).to.equal('http://ex.org/bar#bar');
+        });
+
+        it('should not expand non-registered prefixes', function () {
+          expect(prefixes('baz')('bar')).to.equal('bar');
+        });
+
+        it('should allow registering prefixes', function () {
+          var p = prefixes('baz', 'http://ex.org/baz#');
+          expect(p).to.exist;
+          expect(p).to.equal(prefixes('baz'));
+        });
+
+        it('should expand the newly registered prefix', function () {
+          expect(prefixes('baz')('bar')).to.equal('http://ex.org/baz#bar');
+        });
+      });
+    });
+  });
 });