diff --git a/dist/jsonifier.js b/dist/jsonifier.js index f1d9689..4b6c2ce 100644 --- a/dist/jsonifier.js +++ b/dist/jsonifier.js @@ -2,6 +2,17 @@ const _ = require('lodash'); +/** + * Converts object to only contain static data + * + * Our state data either has static leaf values or functions which yield static + * values. This converst the entire object to only contain static data (subject + * to users creating functions which _only_ yield static output) + * + * @method compiler + * @param {Object} obj Typically jsonifier state object + * @return {Object} + */ function compiler(obj) { if (_.isFunction(obj)) { return obj(); @@ -13,6 +24,11 @@ function compiler(obj) { return obj; } +/** + * Converts generators to functions which yield next value + * + * See [_.assignWith](https://lodash.com/docs#assignInWith) + */ function dynamicCustomiser(objValue, srcValue) { if (_.isFunction(srcValue)) { let result = srcValue(); @@ -23,8 +39,48 @@ function dynamicCustomiser(objValue, srcValue) { return srcValue; } +/** + * Extends an object to make sure it has child attributes + * + * @method createObject + * @param {Object} srcObj The target object + * @param {String} ref Period separated description: + * a.b.c => {a: {b: {c: {}}}} + * @param {Object} finalValue [optional] final value to assign to leaf node: + * a.b.c (final 'foo') => {a: {b: {c: 'foo'}}} + * @return {Object Ref} The final objects 'a.b.c' => {c: {}} + */ +function createObject(srcObj, ref, finalValue) { + let steps = ref.split('.'); + + steps.forEach((attrib, index) => { + srcObj[attrib] = srcObj.hasOwnProperty(attrib) && _.isObject(srcObj[attrib]) ? srcObj[attrib] : {}; + if (index < steps.length - 1) { + srcObj = srcObj[attrib]; + } else { + srcObj = srcObj[attrib] = finalValue; + } + }); + + return srcObj; +} + +/** + * Captures object of JSON data in particular states + * @class {JSONifier} + */ module.exports = class JSONifier { + /** + * @method constructor + * @param {JSONifier} state A JSONifier instance to inherit properties from + * + * @param {Object} ops Optional parameters + * @param {String} ops.namespace Period separated namespace: 'a.b.c' => {'a': {'b': 'c':{}}} + * @param {Integer} ops.limit Limit the number of responses from this instance [default: unlimited] + * @param {Function} ops.compiler Change the way an instance builds JSON object {@link compiler} + * @return {JSONifier} + */ constructor(state, ops) { this.options = { namespace: undefined, @@ -40,28 +96,21 @@ module.exports = class JSONifier { _.extend(this.options, state); } - if (state instanceof JSONifier) { - this._state = _.cloneDeep(state._state); - } else { - this._state = {}; - } + this._state = state instanceof JSONifier ? _.cloneDeep(state._state) : {}; - this._current = _.isUndefined(this.options.namespace) ? this._state : this._state[this.options.namespace] = this._state[this.options.namespace] || {}; + this._current = _.isUndefined(this.options.namespace) ? this._state : createObject(this._state, this.options.namespace, {}); } + /** + * Adds an enhanced 'JSON object' to the current instance + * + * @method add + * @param {String} method [optional] Dot notation: e.g. 'a' or 'a.b.c.d' + * @param {Object|Function|Generator} Yield static data (object, string, number, etc...) + */ add(method, generator) { if (_.isString(method)) { - let obj = this._current; - - let steps = method.split('.'); - const final_step = steps.pop(); - - steps.forEach(attrib => { - obj[attrib] = obj.hasOwnProperty(attrib) && _.isObject(obj[attrib]) ? obj[attrib] : {}; - obj = obj[attrib]; - }); - - obj[final_step] = _.assignWith(generator, generator, dynamicCustomiser); + createObject(this._current, method, _.assignWith(generator, generator, dynamicCustomiser)); return this; } @@ -73,6 +122,11 @@ module.exports = class JSONifier { throw Error('Illegal use of jsonifier#add'); } + /** + * Yields static JSON objects from all inherited instances + * @method build + * @return {Generator} which yields JSON objects + */ build() { let that = this; return function* iterableJSONifier() { @@ -82,4 +136,4 @@ module.exports = class JSONifier { }(); } }; -//# sourceMappingURL=data:application/json;base64,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 +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["index.js"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["'use strict';\nconst _ = require('lodash');\n\n/**\n * Converts object to only contain static data\n *\n * \tOur state data either has static leaf values or functions which yield static\n * \tvalues.  This converst the entire object to only contain static data (subject\n * \tto users creating functions which _only_ yield static output)\n *\n * @method compiler\n * @param  {Object} obj Typically jsonifier state object\n * @return {Object}\n */\nfunction compiler(obj) {\n    if (_.isFunction(obj)) {\n        return obj();\n    } else if (_.isObject(obj)) {\n        let result = {};\n        Object.keys(obj).forEach(key => result[key] = compiler(obj[key]));\n        return result;\n    }\n    return obj;\n}\n\n\n/**\n * Converts generators to functions which yield next value\n *\n * \tSee [_.assignWith](https://lodash.com/docs#assignInWith)\n */\nfunction dynamicCustomiser(objValue, srcValue) {\n    if (_.isFunction(srcValue)) {\n        let result = srcValue();\n        if (result.toString() === '[object Generator]') {\n            srcValue = () => result.next().value;\n        }\n    }\n    return srcValue;\n}\n\n\n/**\n * Extends an object to make sure it has child attributes\n *\n * @method createObject\n * @param  {Object}     srcObj      The target object\n * @param  {String}     ref         Period separated description:\n *                                  \ta.b.c => {a: {b: {c: {}}}}\n * @param  {Object}     finalValue  [optional] final value to assign to leaf node:\n *                                  \ta.b.c (final 'foo') => {a: {b: {c: 'foo'}}}\n * @return {Object Ref} The final objects 'a.b.c' => {c: {}}\n */\nfunction createObject(srcObj, ref, finalValue) {\n    let steps = ref.split('.');\n\n    steps.forEach((attrib, index) => {\n        srcObj[attrib] = srcObj.hasOwnProperty(attrib) && _.isObject(srcObj[attrib])\n            ? srcObj[attrib]\n            : {}\n            ;\n        if (index < steps.length - 1) {\n            srcObj = srcObj[attrib];\n        } else {\n            srcObj = srcObj[attrib] = finalValue;\n        }\n    });\n\n    return srcObj;\n}\n\n\n/**\n * Captures object of JSON data in particular states\n * @class {JSONifier}\n */\nmodule.exports = class JSONifier {\n\n    /**\n     * @method constructor\n     * @param  {JSONifier}      state   A JSONifier instance to inherit properties from\n     *\n     * @param  {Object}         ops             Optional parameters\n     * @param  {String}         ops.namespace   Period separated namespace: 'a.b.c' => {'a': {'b': 'c':{}}}\n     * @param  {Integer}        ops.limit       Limit the number of responses from this instance [default: unlimited]\n     * @param  {Function}       ops.compiler    Change the way an instance builds JSON object {@link compiler}\n     * @return {JSONifier}\n     */\n    constructor(state, ops) {\n        this.options = {\n            namespace: undefined,\n            limit: -1,\n            compiler: compiler\n        };\n\n        if (state instanceof JSONifier && _.isObject(ops)) {\n            _.extend(this.options, ops);\n        }\n\n        if (_.isObject(state) && _.isUndefined(ops)) {\n            _.extend(this.options, state);\n        }\n\n        this._state = state instanceof JSONifier\n            ? _.cloneDeep(state._state)\n            : {}\n            ;\n\n        this._current = _.isUndefined(this.options.namespace)\n            ? this._state\n            : createObject(this._state, this.options.namespace, {})\n            ;\n    }\n\n    /**\n     * Adds an enhanced 'JSON object' to the current instance\n     *\n     * @method add\n     * @param  {String}                     method    [optional] Dot notation: e.g. 'a' or 'a.b.c.d'\n     * @param  {Object|Function|Generator}  Yield static data (object, string, number, etc...)\n     */\n    add(method, generator) {\n        if (_.isString(method)) {\n            createObject(this._current, method, _.assignWith(generator, generator, dynamicCustomiser));\n            return this;\n        }\n\n        if (_.isUndefined(generator) && _.isObject(method)) {\n            _.assignWith(this._current, method, dynamicCustomiser);\n            return this;\n        }\n\n        throw Error('Illegal use of jsonifier#add');\n    }\n\n    /**\n     * Yields static JSON objects from all inherited instances\n     * @method build\n     * @return {Generator}  which yields JSON objects\n     */\n    build() {\n        let that = this;\n        return function* iterableJSONifier() {\n            for(let i=0; i != that.options.limit; i = (i + 1) % Number.MAX_SAFE_INTEGER) {\n                yield that.options.compiler(that._state);\n            }\n        }();\n    }\n};\n"],"sourceRoot":"/source/"} diff --git a/index.js b/index.js index cb0f03f..11eb654 100644 --- a/index.js +++ b/index.js @@ -1,6 +1,17 @@ 'use strict'; const _ = require('lodash'); +/** + * Converts object to only contain static data + * + * Our state data either has static leaf values or functions which yield static + * values. This converst the entire object to only contain static data (subject + * to users creating functions which _only_ yield static output) + * + * @method compiler + * @param {Object} obj Typically jsonifier state object + * @return {Object} + */ function compiler(obj) { if (_.isFunction(obj)) { return obj(); @@ -12,6 +23,12 @@ function compiler(obj) { return obj; } + +/** + * Converts generators to functions which yield next value + * + * See [_.assignWith](https://lodash.com/docs#assignInWith) + */ function dynamicCustomiser(objValue, srcValue) { if (_.isFunction(srcValue)) { let result = srcValue(); @@ -22,8 +39,53 @@ function dynamicCustomiser(objValue, srcValue) { return srcValue; } + +/** + * Extends an object to make sure it has child attributes + * + * @method createObject + * @param {Object} srcObj The target object + * @param {String} ref Period separated description: + * a.b.c => {a: {b: {c: {}}}} + * @param {Object} finalValue [optional] final value to assign to leaf node: + * a.b.c (final 'foo') => {a: {b: {c: 'foo'}}} + * @return {Object Ref} The final objects 'a.b.c' => {c: {}} + */ +function createObject(srcObj, ref, finalValue) { + let steps = ref.split('.'); + + steps.forEach((attrib, index) => { + srcObj[attrib] = srcObj.hasOwnProperty(attrib) && _.isObject(srcObj[attrib]) + ? srcObj[attrib] + : {} + ; + if (index < steps.length - 1) { + srcObj = srcObj[attrib]; + } else { + srcObj = srcObj[attrib] = finalValue; + } + }); + + return srcObj; +} + + +/** + * Captures object of JSON data in particular states + * @class {JSONifier} + */ module.exports = class JSONifier { + /** + * @method constructor + * @param {JSONifier} state A JSONifier instance to inherit properties from + * + * @param {Object} ops Optional parameters + * @param {String} ops.namespace Period separated namespace: 'a.b.c' => {'a': {'b': 'c':{}}} + * @param {Integer} ops.limit Limit the number of responses from this instance [default: unlimited] + * @param {Function} ops.compiler Change the way an instance builds JSON object {@link compiler} + * @return {JSONifier} + */ constructor(state, ops) { this.options = { namespace: undefined, @@ -39,34 +101,27 @@ module.exports = class JSONifier { _.extend(this.options, state); } - if (state instanceof JSONifier) { - this._state = _.cloneDeep(state._state); - } else { - this._state = {}; - } + this._state = state instanceof JSONifier + ? _.cloneDeep(state._state) + : {} + ; this._current = _.isUndefined(this.options.namespace) ? this._state - : this._state[this.options.namespace] = this._state[this.options.namespace] || {} + : createObject(this._state, this.options.namespace, {}) ; } + /** + * Adds an enhanced 'JSON object' to the current instance + * + * @method add + * @param {String} method [optional] Dot notation: e.g. 'a' or 'a.b.c.d' + * @param {Object|Function|Generator} Yield static data (object, string, number, etc...) + */ add(method, generator) { if (_.isString(method)) { - let obj = this._current; - - let steps = method.split('.'); - const final_step = steps.pop(); - - steps.forEach(attrib => { - obj[attrib] = obj.hasOwnProperty(attrib) && _.isObject(obj[attrib]) - ? obj[attrib] - : {} - ; - obj = obj[attrib]; - }); - - obj[final_step] = _.assignWith(generator, generator, dynamicCustomiser); + createObject(this._current, method, _.assignWith(generator, generator, dynamicCustomiser)); return this; } @@ -78,6 +133,11 @@ module.exports = class JSONifier { throw Error('Illegal use of jsonifier#add'); } + /** + * Yields static JSON objects from all inherited instances + * @method build + * @return {Generator} which yields JSON objects + */ build() { let that = this; return function* iterableJSONifier() { diff --git a/test/basic.spec.js b/test/basic.spec.js index fe62af9..75a2892 100644 --- a/test/basic.spec.js +++ b/test/basic.spec.js @@ -6,9 +6,9 @@ function testObj(js, obj) { return js.build().next().value.should.containDeep(obj); } -describe('simple use cases', function() { +describe('varying constructor types', function() { - it('handles simple objects', () => { + it('the simplest case', () => { let simple = new jsonifier().add({ 1: 2 }); @@ -20,11 +20,19 @@ describe('simple use cases', function() { inherit.add({2:3}); testObj(inherit, {1:2, 2:3}); + }); + + it('namespaces, functions & composite', () => { + let simple = new jsonifier().add({ 1: 2 }); + + // Namespaces let dual = new jsonifier(simple, {namespace: 'b'}).add({c: 'd'}); testObj(dual, {1:2, 'b': {c: 'd'}}); + // Functions testObj(new jsonifier().add('a', () => 'success'), {'a': 'success'}); + // Composites testObj(new jsonifier().add('a', { 'b': [ {'c': () => 'd'}, @@ -40,13 +48,30 @@ describe('simple use cases', function() { }).should.throw(/Illegal/); }); - it('handles deep object generation', () => { - let simple = new jsonifier().add('a.b.c', {e: 'f'}); +}); +describe('object creation shortcut notation', function() { + + it('adds generated objects from notation', () => { + let simple = new jsonifier().add('a.b.c', {e: 'f'}); testObj(simple, {'a': {'b': {'c': {'e': 'f'}}}}); }); - it('handles dynamic content', () => { + it('handles namespaces with notation', () => { + // Simple objec5 + let ns = new jsonifier({namespace: 'a.b.c'}).add({'d': 'e'}); + testObj(ns, {'a': {'b': {'c': {'d': 'e'}}}}); + + // Function which would have to be 'compiled' + ns = new jsonifier({namespace: 'a.b.c'}).add('d', () => 'e'); + testObj(ns, {'a': {'b': {'c': {'d': 'e'}}}}); + }); + +}); + +describe('dynamic content', function() { + + it('handling function and generators', () => { // Functions let func = new jsonifier().add({ test: () => 'success' @@ -66,7 +91,11 @@ describe('simple use cases', function() { test.next().value.should.containDeep({'test': 'c'}); test.next().value.should.containDeep({'test': undefined}); - // Other + }); + + it('handles composites of functions, gernerators and static values', () => { + let func = new jsonifier().add({ test: () => 'success' }); + let mega = new jsonifier(func).add('foo.bar', { a: 'woot', bob: function* bob() { @@ -103,14 +132,18 @@ describe('simple use cases', function() { }); }); - it('enforces inheritance order', () => { +}); + +describe('other more subtle stuff', function() { + + it('enforces inheritance order overwriting', () => { let a = new jsonifier().add('a', {b: {c: 'Should not'}, d: 'woot'}); let b = new jsonifier(a).add('a.b', {c: 'make it through'}); let c = new jsonifier(b).add('a.b', {c: 'success'}); testObj(c, {'a': {'b': {'c': 'success'}, 'd': 'woot'}}); }); - it('has functional namespaces', () => { + it('has working namespaces', () => { // Normal namespace use let a = new jsonifier({namespace: 'woot'}).add({'test': 'success'}); testObj(a, {'woot': {'test': 'success'}}); @@ -118,6 +151,14 @@ describe('simple use cases', function() { // Inheritange let b = new jsonifier(a).add('test', {a: 1}); testObj(b, {'woot': {'test': 'success'}, 'test': {a: 1}}); + + // Notation Expansion + let d = new jsonifier(a, {namespace: 'woot.bob.foo'}).add({1:2}); + testObj(d, { 'woot': { 'test': 'success', 'bob': { 'foo': { '1': 2 } } } }); + + // Quirks: undefined namespace as a way to jump to a root attribute if you have to reference namespace + let c = new jsonifier({namespace: undefined}).add({'a': 'b'}); + testObj(c, {'a': 'b'}); }); });