Change circular handling to circular-json compatible handling. Fix undefined values in arrays.

Author: Faleij

jsonStreamify.js

@@ -60,6 +60,7 @@ class JSONStreamify extends CoStream {
                         }
                         first = false;
                         let stream = new JSONStreamify(data, this._iter.replacer, this._iter.space, this._iter.visited);
+                        stream._iter._stack = this._iter._stack;
                         stream._iter._parentCtxType = Array;
                         stream.once('end', () => next(null, undefined)).pipe(pass, {
                             end: false
@@ -72,26 +73,12 @@ class JSONStreamify extends CoStream {
             }
 
             if (obj.state === 'circular') {
-                let replacer;
-                this.emit('circular', Object.assign(obj, {
-                    replace: (promise) => {
-                        if (promise instanceof Promise) {
-                            obj.value = promise;
-                        }
-                    }
-                }));
-
-                // Wait for replace
-                yield new Promise(resolve => process.nextTick(resolve));
-
-                if (!(obj.value instanceof Promise)) {
-                    yield this.push('"[Circular]"');
-                }
+                yield this.push(JSON.stringify(`~${obj.value.join('~')}`));
             }
 
             if (obj.value instanceof Promise) {
-                let childIterator = new RecursiveIterable(yield obj.value, this._iter.replacer, this._iter.space, this._iter.visited)[Symbol.iterator]();
-                obj.value = obj.attachChild(childIterator);
+                let childIterator = new RecursiveIterable(yield obj.value, this._iter.replacer, this._iter.space, this._iter.visited, this._iter._stack)[Symbol.iterator]();
+                obj.value = obj.attachChild(childIterator, obj.key);
                 insertSeparator = false;
                 continue;
             }

recursiveIterable.js

@@ -4,17 +4,18 @@ const Readable = require('stream').Readable;
 const isReadableStream = require('./utils').isReadableStream;
 
 class RecursiveIterable {
-    constructor(obj, replacer, space, visited) {
+    constructor(obj, replacer, space, visited, stack) {
         // Save a copy of the root object so we can be memory effective
         if (obj && typeof obj.toJSON === 'function') {
             obj = obj.toJSON();
         }
         this.exclude = [Promise, {
             __shouldExclude: isReadableStream
         }];
-        this.visited = visited || new WeakSet();
+        this._stack = stack || [];
+        this.visited = visited || new WeakMap();
         if (this._shouldIterate(obj)) {
-            this.visited.add(obj);
+            this.visited.set(obj, this._stack.slice(0));
         }
         this.obj = this._shouldIterate(obj) ? (Array.isArray(obj) ? obj.slice(0) : Object.assign({}, obj)) : obj;
         this.replacerIsArray = Array.isArray(replacer);
@@ -34,12 +35,16 @@ class RecursiveIterable {
         let isObject = this._shouldIterate(this.obj);
         let ctxType = RecursiveIterable._getType(this.obj);
         let nextIndex = 0;
-        let keys = isObject && Object.keys(this.obj);
+        let keys = isObject && (Array.isArray(this.obj) ? Array.from(Array(this.obj.length).keys()) : Object.keys(this.obj));
         let childIterator;
         let closed = !isObject;
         let opened = closed;
 
-        const attachIterator = iterator => childIterator = iterator;
+        const attachIterator = (iterator, addToStack) => {
+            childIterator = iterator;
+            childIterator._stack = this._stack.concat(addToStack || []);
+        };
+
         const ctx = {
             depth: 0,
             type: ctxType,
@@ -108,9 +113,10 @@ class RecursiveIterable {
                     if (this._shouldIterate(val)) {
                         if (this.visited.has(val)) {
                             state = 'circular';
+                            val = this.visited.get(val);
                         } else {
                             state = 'child';
-                            childIterator = new RecursiveIterable(val, this.replacer, this.space, this.visited)[Symbol.iterator]();
+                            childIterator = new RecursiveIterable(val, this.replacer, this.space, this.visited, this._stack.concat(key))[Symbol.iterator]();
                             childIterator.ctxType = ctx.type;
                             childIterator.depth = ctx.depth + 1;
                             childIterator.type = RecursiveIterable._getType(val);
@@ -129,6 +135,7 @@ class RecursiveIterable {
                         key: key,
                         value: val,
                         state: state,
+                        stack: this._stack.slice(0),
                         type: type,
                         ctxType: ctx.type,
                         attachChild: attachIterator

test.js

@@ -139,68 +139,13 @@ describe('Streamify', () => {
         })
     }, `{"a":[{"name":"name","arr":[],"date":"${date.toJSON()}"}]}`));
 
-    it(`{ a: [Circular] } should be {"a":"[Circular]"}`, () => {
-        let data = {};
-        data.a = data;
-
-        let deferred0 = Promise.defer();
-        let deferred1 = Promise.defer();
-        let str = '';
-        new JSONStreamify(data)
-            .once('circular', err => {
-                try {
-                    expect(err).to.be.ok();
-                } catch (err) {
-                    return deferred1.reject(err);
-                }
-                deferred1.resolve();
-            })
-            .on('data', data => str += data.toString())
-            .once('end', () => {
-                try {
-                    expect(str).to.equal(`{"a":"[Circular]"}`);
-                } catch (err) {
-                    return deferred0.reject(err);
-                }
-                deferred0.resolve();
-            });
-
-        return Promise.all([deferred0.promise, deferred1.promise]);
-    });
-
-    it(`{ a: [Circular] } should be {"a":"custom"}`, () => {
-        let data = {};
-        data.a = data;
-
-        let deferred0 = Promise.defer();
-        let deferred1 = Promise.defer();
-        let str = '';
-        new JSONStreamify(data)
-            .once('circular', err => {
-                try {
-                    expect(err).to.be.ok();
-                    expect(err.replace).to.be.a(Function);
-                    err.replace(Promise.resolve('custom'));
-                } catch (err) {
-                    return deferred1.reject(err);
-                }
-                deferred1.resolve();
-            })
-            .on('data', data => str += data.toString())
-            .once('end', () => {
-                try {
-                    expect(str).to.equal(`{"a":"custom"}`);
-                } catch (err) {
-                    return deferred0.reject(err);
-                }
-                deferred0.resolve();
-            });
-
-        return Promise.all([deferred0.promise, deferred1.promise]);
-    });
-
     let circularData0 = {};
     circularData0.a = circularData0;
-    circularData0.b = [circularData0, { a: circularData0 }]
-    it('{a: Circular, b: [Circular, { a: Circular }]} should be {"a":"[Circular]","b":["[Circular]",{"a":"[Circular]"}]}', createTest(circularData0, '{"a":"[Circular]","b":["[Circular]",{"a":"[Circular]"}]}'));
+    it(`{ a: a } should be {"a":"~"}`, createTest(circularData0, `{"a":"~"}`));
+
+    let circularData1 = {};
+    circularData1.a = circularData1;
+    circularData1.b = [circularData1, { a: circularData1 }]
+    circularData1.b[3] = circularData1.b[1];
+    it('{a: a, b: [a, { a: a },,a.b.1]} should be {"a":"~","b":["~",{"a":"~"},null,"~b~1"]}', createTest(circularData1, '{"a":"~","b":["~",{"a":"~"},null,"~b~1"]}'));
 });