Return value (in 'stream mode') is now a Transform stream

Author: CMTegner

index.js

@@ -1,42 +1,68 @@
+var util = require('util');
+var Transform = require('stream').Transform;
 var Parser = require('htmlparser2').Parser;
 var isEmpty = require('lodash.isempty');
 
-module.exports = function(markup, callback) {
-    var parent = [];
-    var parser = new Parser({
+util.inherits(JSONMLParser, Transform);
+
+function JSONMLParser() {
+    Transform.call(this);
+    this._readableState.objectMode = true;
+    this._parent = [];
+    this.source = new Parser(this._createSourceOptions());
+}
+
+JSONMLParser.prototype._transform = function(chunk, encoding, done) {
+    this.source.write(chunk, encoding);
+    done();
+};
+
+JSONMLParser.prototype._flush = function(done) {
+    this._onParseDone = done;
+    this.source.end();
+    done();
+};
+
+JSONMLParser.prototype._createSourceOptions = function() {
+    var transform = this;
+    return {
         onopentag: function(tagName, attributes) {
             var elementList = [];
             var element = [tagName, attributes, elementList];
-            parent.push(element);
-            elementList.parent = parent;
-            parent = elementList;
+            transform._parent.push(element);
+            elementList.parent = transform._parent;
+            transform._parent = elementList;
         },
         ontext: function(text) {
-            parent.push(['#text', text]);
+            transform._parent.push(['#text', text]);
         },
         oncomment: function(text) {
-            parent.push(['#comment', text]);
+            transform._parent.push(['#comment', text]);
         },
         onclosetag: function() {
-            var p = parent.parent;
+            var p = transform._parent.parent;
             // Delete elementList and/or attributes if empty
             var lastChild = p[p.length - 1];
             for (var i = 2; i > 0; i--) {
                 if (isEmpty(lastChild[i])) {
                     lastChild.splice(i, 1);
                 }
             }
-            delete parent.parent;
-            parent = p;
+            delete transform._parent.parent;
+            transform._parent = p;
         },
         onerror: function(err) {
-            parser.emit('error', err);
+            transform.emit('error', err);
         },
         onend: function() {
-            parser.emit('data', parent);
-            parser.emit('end');
+            transform.push(transform._parent);
+            transform._onParseDone();
         }
-    });
+    };
+};
+
+module.exports = function(markup, callback) {
+    var parser = new JSONMLParser();
     if (isEmpty(arguments)) {
         return parser;
     } else {

test/test.js

@@ -1,17 +1,33 @@
 var fs = require('fs');
 var test = require('tape');
+var Transform = require('stream').Transform;
 var jsonmlify = require('../');
 
 function verify(markup, expected, t) {
+    var result;
     jsonmlify()
         .on('data', function(data) {
-            t.deepEqual(data, expected);
+            result = data;
+        })
+        .on('end', function() {
+            t.deepEqual(result, expected);
             t.end();
         })
         .end(markup);
 }
 
-test('should return an empty array for empty input markup', function(t) {
+test('should return a transform stream', function(t) {
+    t.ok(jsonmlify() instanceof Transform);
+    t.ok(new jsonmlify() instanceof Transform);
+    t.end();
+});
+
+test('should not return anything in \'callback mode\'', function(t) {
+    t.equal(jsonmlify('foo', function() {}), undefined);
+    t.end();
+});
+
+test('should emit an empty array for empty input markup', function(t) {
     var markup = fs.readFileSync(__dirname + '/01-empty/markup.html', 'utf8');
     var expected = require('./01-empty/expected.json');
     verify(markup, expected, t);
@@ -41,7 +57,7 @@ test('should parse comments', function(t) {
     verify(markup, expected, t);
 });
 
-test('should also expose a node-style callback API', function(t) {
+test('should also offer a node-style callback API', function(t) {
     jsonmlify('<div></div>', function(err, result) {
         t.notOk(err);
         t.deepEqual(result, [['div']]);
@@ -50,11 +66,18 @@ test('should also expose a node-style callback API', function(t) {
 });
 
 test('should report errors', function(t) {
+    var errorCount = 0;
     var stream = jsonmlify();
     stream.on('error', function(err) {
+        errorCount++;
         t.ok(err);
-        t.end();
+        if (errorCount === 2) {
+            t.end();
+        }
     });
     stream.end();
-    stream.write('<div></div>'); // Write after close to provoke an error
-});
+    // Write after end to provoke an error in the writable stream
+    stream.write('<div></div>');
+    // Write to HTML parser after end to provoke an internal error
+    stream.source.write('<div></div>');
+});