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