n3 0.4.2 → 0.5.0

package/test/N3Writer-test.js

@@ -197,7 +197,7 @@ describe('N3Writer', function () {
     it('calls the done callback when ending the outputstream errors', function (done) {
       var writer = new N3Writer({
         write: function () {},
-        end: function () { throw 'error'; },
+        end: function () { throw new Error('error'); },
       });
       writer.end(done);
     });
@@ -269,6 +269,211 @@ describe('N3Writer', function () {
       });
     });
 
+    it('should serialize triples with an empty blank node as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a1', 'b', writer.blank());
+      writer.addTriple('a2', 'b', writer.blank([]));
+      writer.end(function (error, output) {
+        output.should.equal('<a1> <b> [].\n' +
+                            '<a2> <b> [].\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a one-triple blank node as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a1', 'b', writer.blank('d', 'e'));
+      writer.addTriple('a2', 'b', writer.blank({ predicate: 'd', object: 'e' }));
+      writer.addTriple('a3', 'b', writer.blank([{ predicate: 'd', object: 'e' }]));
+      writer.end(function (error, output) {
+        output.should.equal('<a1> <b> [ <d> <e> ].\n' +
+                            '<a2> <b> [ <d> <e> ].\n' +
+                            '<a3> <b> [ <d> <e> ].\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a two-triple blank node as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a', 'b', writer.blank([
+          { predicate: 'd', object: 'e' },
+          { predicate: 'f', object: '"g"' },
+      ]));
+      writer.end(function (error, output) {
+        output.should.equal('<a> <b> [\n' +
+                            '  <d> <e>;\n' +
+                            '  <f> "g"\n' +
+                            '].\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a three-triple blank node as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a', 'b', writer.blank([
+        { predicate: 'd', object: 'e' },
+        { predicate: 'f', object: '"g"' },
+        { predicate: 'h', object: 'i' },
+      ]));
+      writer.end(function (error, output) {
+        output.should.equal('<a> <b> [\n' +
+                            '  <d> <e>;\n' +
+                            '  <f> "g";\n' +
+                            '  <h> <i>\n' +
+                            '].\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with predicate-sharing blank node triples as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a', 'b', writer.blank([
+        { predicate: 'd', object: 'e' },
+        { predicate: 'd', object: 'f' },
+        { predicate: 'g', object: 'h' },
+        { predicate: 'g', object: 'i' },
+      ]));
+      writer.end(function (error, output) {
+        output.should.equal('<a> <b> [\n' +
+                            '  <d> <e>, <f>;\n' +
+                            '  <g> <h>, <i>\n' +
+                            '].\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with nested blank nodes as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a1', 'b', writer.blank([
+        { predicate: 'd', object: writer.blank() },
+      ]));
+      writer.addTriple('a2', 'b', writer.blank([
+        { predicate: 'd', object: writer.blank('e', 'f') },
+        { predicate: 'g', object: writer.blank('h', '"i"') },
+      ]));
+      writer.addTriple('a3', 'b', writer.blank([
+        { predicate: 'd', object: writer.blank([
+          { predicate: 'g', object: writer.blank('h', 'i') },
+          { predicate: 'j', object: writer.blank('k', '"l"') },
+        ]) },
+      ]));
+      writer.end(function (error, output) {
+        output.should.equal('<a1> <b> [\n' +
+                            '  <d> []\n' +
+                            '].\n' +
+                            '<a2> <b> [\n' +
+                            '  <d> [ <e> <f> ];\n' +
+                            '  <g> [ <h> "i" ]\n' +
+                            '].\n' +
+                            '<a3> <b> [\n' +
+                            '  <d> [\n' +
+                            '  <g> [ <h> <i> ];\n' +
+                            '  <j> [ <k> "l" ]\n' +
+                            ']\n' +
+                            '].\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with an empty blank node as subject', function (done) {
+      var writer = N3Writer();
+      writer.addTriple(writer.blank(), 'b', 'c');
+      writer.addTriple(writer.blank([]), 'b', 'c');
+      writer.end(function (error, output) {
+        output.should.equal('[] <b> <c>.\n' +
+                            '[] <b> <c>.\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a one-triple blank node as subject', function (done) {
+      var writer = N3Writer();
+      writer.addTriple(writer.blank('a', 'b'), 'c', 'd');
+      writer.addTriple(writer.blank({ predicate: 'a', object: 'b' }), 'c', 'd');
+      writer.addTriple(writer.blank([{ predicate: 'a', object: 'b' }]), 'c', 'd');
+      writer.end(function (error, output) {
+        output.should.equal('[ <a> <b> ] <c> <d>.\n' +
+                            '[ <a> <b> ] <c> <d>.\n' +
+                            '[ <a> <b> ] <c> <d>.\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with an empty blank node as graph', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a', 'b', 'c', writer.blank());
+      writer.addTriple('a', 'b', 'c', writer.blank([]));
+      writer.end(function (error, output) {
+        output.should.equal('[] {\n<a> <b> <c>\n}\n' +
+                            '[] {\n<a> <b> <c>\n}\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with an empty list as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a1', 'b', writer.list());
+      writer.addTriple('a2', 'b', writer.list([]));
+      writer.end(function (error, output) {
+        output.should.equal('<a1> <b> ().\n' +
+                            '<a2> <b> ().\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a one-element list as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a1', 'b', writer.list(['c']));
+      writer.addTriple('a2', 'b', writer.list(['"c"']));
+      writer.end(function (error, output) {
+        output.should.equal('<a1> <b> (<c>).\n' +
+                            '<a2> <b> ("c").\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a three-element list as object', function (done) {
+      var writer = N3Writer();
+      writer.addTriple('a1', 'b', writer.list(['c', 'd', 'e']));
+      writer.addTriple('a2', 'b', writer.list(['"c"', '"d"', '"e"']));
+      writer.end(function (error, output) {
+        output.should.equal('<a1> <b> (<c> <d> <e>).\n' +
+                            '<a2> <b> ("c" "d" "e").\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with an empty list as subject', function (done) {
+      var writer = N3Writer();
+      writer.addTriple(writer.list(),   'b1', 'c');
+      writer.addTriple(writer.list([]), 'b2', 'c');
+      writer.end(function (error, output) {
+        output.should.equal('() <b1> <c>;\n' +
+                            '    <b2> <c>.\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a one-element list as subject', function (done) {
+      var writer = N3Writer();
+      writer.addTriple(writer.list(['a']), 'b1', 'c');
+      writer.addTriple(writer.list(['a']), 'b2', 'c');
+      writer.end(function (error, output) {
+        output.should.equal('(<a>) <b1> <c>;\n' +
+                            '    <b2> <c>.\n');
+        done(error);
+      });
+    });
+
+    it('should serialize triples with a three-element list as subject', function (done) {
+      var writer = N3Writer();
+      writer.addTriple(writer.list(['a', '"b"', '"c"']), 'd', 'e');
+      writer.end(function (error, output) {
+        output.should.equal('(<a> "b" "c") <d> <e>.\n');
+        done(error);
+      });
+    });
+
     it('should accept triples in bulk', function (done) {
       var writer = N3Writer();
       writer.addTriples([{ subject: 'a', predicate: 'b', object: 'c' },
@@ -327,6 +532,33 @@ describe('N3Writer', function () {
         done();
       });
     });
+
+    it('should end when the end option is not set', function (done) {
+      var outputStream = new QuickStream(), writer = N3Writer(outputStream, {});
+      outputStream.should.have.property('ended', false);
+      writer.end(function () {
+        outputStream.should.have.property('ended', true);
+        done();
+      });
+    });
+
+    it('should end when the end option is set to true', function (done) {
+      var outputStream = new QuickStream(), writer = N3Writer(outputStream, { end: true });
+      outputStream.should.have.property('ended', false);
+      writer.end(function () {
+        outputStream.should.have.property('ended', true);
+        done();
+      });
+    });
+
+    it('should not end when the end option is set to false', function (done) {
+      var outputStream = new QuickStream(), writer = N3Writer(outputStream, { end: false });
+      outputStream.should.have.property('ended', false);
+      writer.end(function () {
+        outputStream.should.have.property('ended', false);
+        done();
+      });
+    });
   });
 });
 
@@ -344,13 +576,14 @@ function shouldSerialize(prefixes, tripleArrays, expectedResult) {
         writer.end(function (error) {
           try {
             outputStream.result.should.equal(expectedResult);
+            outputStream.should.have.property('ended', true);
             done(error);
           }
           catch (e) {
             done(e);
           }
         });
-    })();
+    }());
   };
 }
 
@@ -370,8 +603,16 @@ function shouldNotSerialize(tripleArrays, expectedMessage) {
 }
 
 function QuickStream() {
-  var stream = {}, buffer = '';
-  stream.write = function (chunk, encoding, callback) { buffer += chunk; callback && callback(); };
-  stream.end = function (callback) { stream.result = buffer; buffer = null; callback(); };
+  var stream = { ended: false }, buffer = '';
+  stream.write = function (chunk, encoding, callback) {
+    buffer += chunk;
+    callback && callback();
+  };
+  stream.end = function (callback) {
+    stream.ended = true;
+    stream.result = buffer;
+    buffer = null;
+    callback();
+  };
   return stream;
 }

package/.jshintrc

@@ -1,20 +0,0 @@
-{
-  "node": true,     // Allow use of node.js globals.
-  "loopfunc": true, // Allow functions to be defined within loops.
-  "proto": true,    // Allow use of `__proto__`.
-  "expr": true,     // Allow expressions where statements are allowed.
-  "boss": true,     // Allow assignments where expressions are allowed.
-  "trailing": true, // Do not leave trailing whitespace.
-  "strict": false,  // Do not enforce strict mode.
-  "undef": true,    // Don't use undefined variables.
-  "unused": true,   // Warn about unused variables.
-  "-W086": true,    // Allow fall-through in switch statement.
-  "white": true,    // Enable strict whitespace checking.
-  "indent": 2,      // The code uses an indentation width of 2 spaces.
-  "globals": {      // Allow mocha globals in tests.
-    "describe": true,
-    "it": true,
-    "before": true,
-    "beforeEach": true
-  }
-}