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.

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.

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'}

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']}

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

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

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

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.