Coverage

100%

155

lib/abstract.js

100%

102

Line	Hits	Source
1		'use strict';
2
3	1	var _ = require('underscore');
4
5
6		function lcfirst(property) {
7	66	return [property.charAt(0).toLowerCase(), property.substr(1)].join('');
8		}
9
10
11		function plucker(data, property) {
12	12	return _.object(_.keys(data), _.pluck(data, property));
13		}
14
15
16		function defineProperty(object, property, value, enumerable) {
17	843	return Object.defineProperty(object, property, {
18		enumerable: enumerable \|\| false,
19		configurable: false,
20		writable: false,
21		value: value
22		});
23		}
24
25
26		function setProperties(object, properties) {
27	56	return _.each(properties, function (value, key) {
28	560	return defineProperty(object, key, value);
29		});
30		}
31
32
33		function abstract(namespace, schema, defaults) {
34	57	var object = {},
35		setters = {},
36		getters = {},
37		validators = {};
38
39	57	defineProperty(object, '_data', {});
40	57	defineProperty(object, '_gleam', namespace);
41
42		function set(values) {
43	41	if (!_.isObject(values) \|\| _.isArray(values) \|\| _.isFunction(values)) {
44	4	throw new Error('Values must be an object');
45		}
46	37	_.each(values, function (value, key) {
47	96	return setKey(key, value, values);
48		});
49		}
50
51		function get() {
52	6	var data = {};
53	6	_.each(object._data, function (property, key) {
54	15	var value = getKey(key);
55	15	if (_.isArray(value)) {
56	2	data[key] = [];
57	2	_.each(value, function (item) {
58	4	if (_.isObject(item) && !_.isEmpty(item._gleam)) {
59	2	data[key].push(item.get());
60		} else {
61	2	data[key].push(item);
62		}
63		});
64	13	} else if (_.isObject(value) && !_.isEmpty(value._gleam)) {
65	1	data[key] = value.get();
66		} else {
67	12	data[key] = value;
68		}
69		});
70	6	return data;
71		}
72
73
74		function isValid(key, value, values) {
75	100	if (_.isUndefined(values)) {
76	4	values = {};
77	4	values[key] = value;
78		}
79	100	if (!_.has(schema, key)) {
80	9	return false;
81		}
82	91	if (_.has(validators, key)) {
83	20	return validators[key](value, values, object);
84		}
85	71	return true;
86		}
87
88
89		function setValue(key, value, values) {
90	88	if (_.has(setters, key)) {
91	3	object._data[key].value = setters[key](value, values, object);
92		} else {
93	85	object._data[key].value = value;
94		}
95	88	object._data[key].modified = true;
96	88	return object;
97		}
98
99
100		function setKey(key, value, values) {
101	98	if (isValid(key, value, values)) {
102	88	return setValue(key, value, values);
103		}
104	10	if (_.has(schema, key)) {
105	1	throw new Error('Value [' + value + '] is not valid for [' + namespace + '.' + key + ']');
106		}
107	9	return object;
108		}
109
110
111		function getKey(key) {
112	33	if (!_.has(object._data, key)) {
113	1	throw new Error('Accessing undefined property [' + namespace + '.' + key + ']');
114		}
115	32	if (_.has(getters, key)) {
116	4	return getters[key](object);
117		}
118	28	return object._data[key].value;
119		}
120
121
122	57	_.each(schema, function (value, key) {
123	236	if (!_.isFunction(value)) {
124	1	throw new Error('Entity schema must not have any properties [' + namespace + '.' + key + ']');
125		}
126	235	if (key.substr(0, 4) === '_set') {
127	15	setters[lcfirst(key.substr(4))] = value;
128	15	return;
129		}
130	220	if (key.substr(0, 4) === '_get') {
131	15	getters[lcfirst(key.substr(4))] = value;
132	15	return;
133		}
134	205	if (key.substr(0, 9) === '_validate') {
135	36	validators[lcfirst(key.substr(9))] = value;
136	36	return;
137		}
138
139	169	object._data[key] = {
140		initial: value(),
141		modified: false,
142		value: value()
143		};
144
145	169	defineProperty(object, key, function (value) {
146	18	if (_.isUndefined(value)) {
147	16	return getKey(key);
148		}
149	2	setKey(key, value);
150	2	return object;
151		}, true);
152		});
153
154
155		function getFlat() {
156	2	var data = {};
157	2	_.each(object._data, function (property, key) {
158	9	if (_.isArray(property.value)) {
159	2	data[key] = [];
160	2	_.each(property.value, function (item) {
161	4	if (!_.isObject(item) \|\| _.isEmpty(item._gleam)) {
162	2	data[key].push(item);
163		}
164		});
165	7	} else if (!_.isObject(property.value) \|\| _.isEmpty(property.value._gleam)) {
166	6	data[key] = property.value;
167		}
168		});
169	2	return data;
170		}
171
172
173		function toJson() {
174	9	var data = {};
175	9	_.each(object._data, function (property, key) {
176	23	if (_.isArray(property.value)) {
177	2	data[key] = [];
178	2	_.each(property.value, function (item) {
179	4	if (_.isObject(item) && !_.isEmpty(item._gleam)) {
180	2	data[key].push(item.toJSON());
181		} else {
182	2	data[key].push(item);
183		}
184		});
185	21	} else if (_.isObject(property.value) && !_.isEmpty(property.value._gleam)) {
186	2	data[key] = property.value.toJSON();
187		} else {
188	19	data[key] = property.value;
189		}
190		});
191	9	data.__ns = namespace;
192	9	return data;
193		}
194
195
196	56	setProperties(object, {
197		set: set,
198		get: get,
199		getProperty: getKey,
200		getFlat: getFlat,
201		initial: function () {
202	6	return plucker(object._data, 'initial');
203		},
204		modified: function () {
205	6	return plucker(object._data, 'modified');
206		},
207		is: function (ns) {
208	9	return ns === namespace;
209		},
210		isValid: isValid,
211		toJSON: toJson,
212		toString: function () {
213	6	return ['[', 'object', ' ', 'Gleam:', namespace, ']'].join('');
214		}
215		});
216
217
218	56	if (defaults) {
219	33	set(defaults);
220
221		// Set modified key back to false and fill initial value
222	32	_.each(object._data, function (property) {
223	95	property.modified = false;
224	95	property.initial = property.value;
225		});
226		}
227
228
229	55	return object;
230		}
231
232
233	1	module.exports = exports = abstract;
234

lib/build-sync.js

100%

Line	Hits	Source
1		"use strict";
2
3	1	var path = require('path');
4	1	var _ = require('underscore');
5	1	var fs = require('fs');
6	1	var glob = require('glob');
7	1	var mkdirp = require('mkdirp');
8
9
10		function getPaths(root) {
11	1	var files = {
12		'from-json': {
13		template: path.join(__dirname, 'browser', 'from-json.txt')
14		},
15		'abstract': {
16		template: path.join(__dirname, 'browser', 'abstract.txt'),
17		content: path.join(__dirname, 'abstract.js')
18		}
19		};
20	1	glob.sync("*/.js", {cwd: root}).forEach(function (entityPath) {
21	7	files[entityPath.replace('.js', '')] = {
22		template: path.join(__dirname, 'browser', 'entity.txt'),
23		content: path.join(root, entityPath)
24		};
25		});
26	1	return files;
27		}
28
29
30	1	var removeStrictRegexp = new RegExp('\\s[\'"]use strict[\'"];\\s', 'ig');
31
32
33		function renderFile(namespace, file, out) {
34	9	var template = _.template(fs.readFileSync(file.template, 'UTF-8')),
35		content = template({
36		namespace: namespace,
37		content: file.content && fs.readFileSync(file.content, 'UTF-8').replace(removeStrictRegexp, '') \|\| ''
38		}),
39		outDir = path.join(out, path.join.apply(path, _.initial(namespace.split('/')))),
40		outFile = path.join(out, namespace + '.js');
41
42	9	mkdirp.sync(outDir);
43	9	fs.writeFileSync(outFile, content);
44	9	return true;
45		}
46
47
48		function render(files, out) {
49	1	return _.reduce(files, function (memo, file, namespace) {
50	9	return memo && renderFile(namespace, file, out);
51		}, true);
52		}
53
54		function build(input, out) {
55	1	return render(getPaths(input), out);
56		}
57
58	1	module.exports = exports = build;
59

lib/entity.js

100%

Line	Hits	Source
1		"use strict";
2
3	1	var abstract = require('./abstract');
4	1	var path = require('path');
5	1	var _ = require('underscore');
6
7
8		function entity(root, namespace, data) {
9	59	var schema = require(path.join(root, namespace)).Entity;
10	59	if (!_.isObject(schema)) {
11	2	throw new Error("Entity must be an object");
12		}
13	57	return abstract(namespace, schema, data);
14		}
15
16	1	module.exports = exports = entity;
17

lib/from-json.js

100%

Line	Hits	Source
1		'use strict';
2
3	1	var _ = require('underscore');
4	1	var entity = require('./entity');
5
6
7		function fromJson(root, json) {
8	11	return JSON.parse(json, function (key, value) {
9	103	if (_.isObject(value) && !_.isUndefined(value.__ns)) {
10	22	var namespace = value.__ns;
11	22	delete value.__ns;
12	22	return entity(root, namespace, value);
13		}
14	81	return value;
15		});
16		}
17
18	1	module.exports = exports = fromJson;
19

lib/index.js

100%

Line	Hits	Source
1		"use strict";
2
3	1	var entity = require('./entity');
4	1	var is = require('./is');
5	1	var fromJson = require('./from-json');
6	1	var buildSync = require('./build-sync');
7	1	var _ = require('underscore');
8
9
10		/**
11		* @constructor
12		* @param root
13		* @property _root
14		*/
15		function Gleam(root) {
16	6	if (_.isEmpty(root)) {
17	1	throw new Error('Root must be set');
18		}
19	5	this._root = root;
20		}
21
22
23		/**
24		* @param {String} namespace
25		* @param {Object?} data
26		* @return {Entity}
27		*/
28	1	Gleam.prototype.entity = function (namespace, data) {
29	37	return entity(this._root, namespace, data);
30		};
31
32
33		/**
34		* @param {String} json
35		* @return {*}
36		*/
37	1	Gleam.prototype.fromJson = function (json) {
38	11	return fromJson(this._root, json);
39		};
40
41
42		/**
43		* @function
44		* @param {Object} entity
45		* @param {String} namespace
46		*/
47	1	Gleam.is = is;
48
49
50		/**
51		* @function
52		* @param {String} input Input directory
53		* @param {String} out Output directory
54		*/
55	1	Gleam.buildSync = buildSync;
56
57
58	1	module.exports = exports = Gleam;
59

lib/is.js

100%

Line	Hits	Source
1		"use strict";
2
3	1	var _ = require('underscore');
4
5		/**
6		* @api
7		* @static
8		*/
9		function is(entity, namespace) {
10	8	return !_.isEmpty(entity) &&
11		_.isObject(entity) &&
12		_.isFunction(entity.is) &&
13		entity.is(namespace);
14		}
15
16	1	module.exports = exports = is;
17