Problem

let test = new jsonifier().add('test', function* test() { yield 1 });
for (let t of test.build()) {
   console.log(t);
}
> { 'test': 1 }
> { 'test': undefined }
> { 'test': undefined }
> { 'test': undefined }
...

The current solution is to use the limit parameter. This isn't very elegant.

Proposal

Limit now represents these 3 options:

1. Undefined: run until all generators in the jsonifier object have completed
2. -1: Run indefinitely, returning undefined for generators which have completed
3. n, n is natural number. Run for n iterations.

Overview

Currently builds allow namespaces to be built by referencing the namespace as a string argument:

new JSONifier({namespace: 'a'}).add({'b': 'c'}).build('a')
> {'b': 'c'}

Limits

We need more options to allow output to be customised. Namespaces should be used for 2 cases:

• differentiate between various parts of a composite JSON object (I want to use namespaces to include or exclude inherited JSON),
• represent actual key values (I want the namespaces included in the output)

Future

1. Allow: string and object arguments to build:

.build('a')
.build({namespace:'a'}) 

1. Allow multiple namespaces to be build:

.build({namespace:['a', 'b', 'c']}) 

1. Allow namespaces to be merged

let a = new JSONifier({namespace: 'a'})
   .add({'a': '1'})
   .add({'b': '2'});
let b = new JSONifier({namespace: 'b'})
   .add({'b': 'woot'});

b.build('a').next().value
> {'a': '1', 'b': '2'}
b.build({namespace: 'a'}).next().value
> {'a': '1', 'b': '2'}

b.build('b').next().value
> {'b': 'woot'}

b.build().next().value
> {'a': {'a': '1', 'b': '2'}, 'b': {'b': 'woot'}}

b.build({nest: false}).next().value
> {'a': '1', 'b': 'woot'}

Nesting isn't working, tests don't cover correctly. This is the expected behaviour:

Examples:

let a = new JSONifier({namespace: 'a'}).add({1:2});
> a.build({nest: true}).next().value
{'a': {'1': '2'}}
> a.build({nest: false}).next().value
{'1': '2'}
> a.build('a').next().value
{'1': '2'}
> a.build().next().value
{'a': {'1': '2'}}

Used with namespaces

> a.build({namespace: 'a', nest: true}).next().value
{'1': '2'}
> a.build({namespace: 'a', nest: true}).next().value
{'a': {'1': '2'}}

This is useful because it allows us to use namespaces as a filter (see #4).

TODO:

Add test which represent these use cases.

The tests are using containDeep instead of eql, which means we're possibly passing tests incorrectly.

The following doesn't work:

let test = new JSONifier().add({a:[{b: () => 'failure'}])
> test.build().next().value
> { 'a': { '0': 'failure' } }

When we expect:

> {'a': ['failure']}

This means that if we call:

let a = new JSONifier().add('a', function* () { yield* [1,2] });
let b = a.build();
b.next(); b.next();
let c = a.build();
c.next(); // incorrectly is 'undefined'

So it needs to convert generators to iterators in JSONify#build instead of JSONify#add

When inheriting multiple jsonifier objects with namespaces, you only have the child's states. That is to say all the inherited states are lost.

Fixes for #4, meant I had to pull the tests for this feature. The idea was that you could extend a class with JSONifier and have some control over how it internally stored objects before build.

This hasn't really every worked, and is a feature which would be useful.