33 | // Load modules containing generators used in this scope.
34 | with({ core: Popcorn.Core, comm: Popcorn.Common }) {
35 |
36 | var base_object = { // Define the base test case object.
37 | id : 1,
38 | name : 'Woody'
39 | };
40 |
41 | var generator = { // Define the generator object.
42 | name : comm.list('Buzz', 'Slinky') // Alter only the name attribute.
43 | };
44 |
45 | // And run...
46 | var results = core.permutate(generator, base_object);
47 |
48 | }
49 |
58 | var g = gen('test'); // Create a generator g with value 'test'.
59 | g('any input') // Execute the generator g. The result is 'test'.
60 |
65 | var p = prepend('Hello ');
66 | p('world'); // returns 'Hello world'
67 | p('Buzz'); // returns 'Hello Buzz', etc.
68 |
75 | var r = random().int(), // See next section for random generators.
76 | a = append(r);
77 | a('user'); // Will return for example 'user42' or 'user573' etc.
78 |
84 | var r = random().int(),
85 | u = chain(r, function(i) { return append('-' + i); });
86 | u('admin'); // Will return for example 'admin-385' or 'admin-712', etc.
87 |
98 | var randomUser = chain(random().int(), function(i) { return append('-' + i); });
99 | repeat(10, randomUser)('user'); // Generates 10 random user names `user-xyz`.
100 |
105 | var generator = {
106 | id : range(1, 3),
107 | name : {
108 | first : list('Buzz', 'Slinky'),
109 | last : 'Toy'
110 | }
111 | };
112 |
132 | var r = random();
133 | r.int(100, 200); // Returns a random int in the range from 100 to 200
134 | r.element(['a', 'b', 'c']); // Returns one of the chars in argument array.
135 |
141 | RandomLib.myRandGenerator = function() {
142 | ...
143 | // this.int()(); call to core int() generator
144 | // which returns next int value.
145 | ...
146 | };
147 |
178 | var generator = {
179 | id : withState(function(s) { s.id = 1; return gen(s.id); }),
180 | user: withState(function(s) { return gen('user-' + s.id); })
181 | };
182 |
195 | var generator = {
196 | id : setVar('id', random().int()),
197 | user: withVar('id', function(id) { return gen('user-' + id); })
198 | };
199 |
209 | var generator = {
210 | id : range(1, 4),
211 | user: list('admin', 'guest')
212 | };
213 |
218 | [{ id: 1, user: 'admin' },
219 | { id: 1, user: 'guest' },
220 | { id: 2, user: 'admin' },
221 | { id: 2, user: 'guest' },
222 | { id: 3, user: 'admin' },
223 | { id: 3, user: 'guest' },
224 | { id: 4, user: 'admin' },
225 | { id: 4, user: 'guest' }]
226 |
235 | [{ id: 1, user: 'admin' },
236 | { id: 2, user: 'guest' },
237 | { id: 3, user: 'admin' },
238 | { id: 4, user: 'guest' }]
239 | |
237 |
238 | Select an example:
239 |
242 |
243 |
244 | or build a new generator:
245 |
246 |
261 |
262 |
263 |
264 | |
265 |
266 |
267 |
268 |
269 |
270 | |
271 |
16 | * with({ p: Popcorn.All }) {
17 | * ... your generator code ...
18 | * }
19 | *
20 | *
21 | * @namespace Popcorn.All
22 | * @author Adam Smyczek
23 | */
24 | Popcorn.All = function (core, common, dictionary, passwords, names, network) {
25 |
26 | // Merge all packages
27 | return core.merge(core, common, dictionary, passwords, names, network);
28 |
29 | }(Popcorn.Core,
30 | Popcorn.Common,
31 | Popcorn.Dictionary,
32 | Popcorn.Passwords,
33 | Popcorn.Names,
34 | Popcorn.Network);
35 |
36 |
--------------------------------------------------------------------------------
/src/common.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @module Popcorn.Common
3 | * @requires Popcorn.Core
4 | */
5 |
6 | /**
7 | * A collection of most common generators.
8 | *
9 | * @namespace Popcorn.Common
10 | * @author Adam Smyczek
11 | */
12 | Popcorn.Common = function (core) {
13 |
14 | var lib = {};
15 |
16 | // Some internal constants
17 | var alpha = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
18 | var digit = '0123456789';
19 | var alpha_num = alpha + digit;
20 |
21 | /**
22 | * Concats arguments (primitives single result generators)
23 | * into one string.
24 | *
25 | * @function {generator[string]} concat
26 | * @param {[generator/primitives]} value - single value
27 | * generators or primitives to concatenate.
28 | */
29 | var concat = lib.concat = function() {
30 | var args = core.args2array(arguments), gs = [], v;
31 | for (var i = 0, l = args.length; i < l; i++) {
32 | v = args[i];
33 | gs[i] = core.isFunction(v)? v : core.gen(v);
34 | }
35 | return core.seq(gs, core.cJoin, "");
36 | };
37 |
38 | /**
39 | * 'range' generator creates a list of integer generators
40 | * in the range from min to max. This is a range function
41 | * and accepts no arguments, or one or two integer arguments.
42 | * For example:
43 | *
44 | * var o = { int : 0 }
45 | * var gen = { int : range(1, 3);
46 | * generate(gen, o) will return:
47 | * [{ int : 1 }, { int : 2 }, { int : 3 }]
48 | *
49 | *
50 | * @function {generator[int]} range
51 | * @paramset No arguments - generates a range from 0 to 100.
52 | * @paramset One int argument - generates a range from 0 to max.
53 | * @param {integer} max - range max value.
54 | * @paramset two int arguments - from-to range.
55 | * @param {integer} min - from integer
56 | * @param {integer} max - to integer
57 | *
58 | * @see Popcorn.Utils.args2range
59 | */
60 | var range = lib.range = function() {
61 | var mm = core.args2range(arguments, 0, 100),
62 | l = mm[1] - mm[0],
63 | r = [];
64 | for (var i = 0; i <= l; i++) {
65 | r[i] = core.gen(mm[0] + i);
66 | }
67 | return r;
68 | };
69 |
70 | /**
71 | * Converts input arguments into a generator array [gen(arguments[i])].
74 | * var o = { name : 'Woody' }
75 | * var gen = { name : list('Buzz', 'Slinky');
76 | * generate(gen, o) will return:
77 | * [{ name : 'Buzz' }, { name : 'Slinky' }]
78 | *
79 | *
80 | * @function {generator[any]} list
81 | * @param {any+} args - the values to generate.
82 | */
83 | var list = lib.list = function() {
84 | var args = core.args2array(arguments);
85 | return function(o, s) {
86 | var rs = [], r;
87 | for (var i = 0, l = args.length; i < l; i++) {
88 | r = args[i];
89 | if (core.isArray(r)) {
90 | rs.push.apply(rs, list.apply(this, r)(o, s).result);
91 | } else {
92 | rs.push(r);
93 | }
94 | }
95 | return { result: rs, state: s };
96 | };
97 | // return core.mapGen(core.args2array(arguments));
98 | };
99 |
100 | /**
101 | * Joins arguments together. Generator arguments
102 | * are evaluated and array arguments join recursive.
103 | *
104 | * @function {generator} join
105 | * @param {any+} args - values, arrays or generators.
106 | */
107 | var join = lib.join = function() {
108 | var args = core.args2array(arguments);
109 | return function(o, s) {
110 | var rs = "", ns = s, gr, r;
111 | for (var i = 0, l = args.length; i < l; i++) {
112 | r = args[i];
113 | switch(core.typeOf(r)) {
114 | case 'function' :
115 | gr = r(o, s);
116 | rs += gr.result;
117 | ns = gr.state;
118 | break;
119 | case 'array' :
120 | gr = join.apply(this, r)(o, s);
121 | rs += gr.result;
122 | ns = gr.state;
123 | break;
124 | default:
125 | rs += r;
126 | break;
127 | }
128 | }
129 | return { result: rs, state: ns };
130 | };
131 | };
132 |
133 | // ------ Prepend/append generators ------
134 |
135 | // Internal prepend/append function prepends/appends
136 | // to default value based on handler function.
137 | var pre_a_pend = function(h) {
138 | return function(g, v) {
139 | return function(o, s) {
140 | var pv = v || o;
141 | switch (core.typeOf(g)) {
142 | case 'array' :
143 | var rs = [], ns = s, r;
144 | for (var i = 0, l = g.length; i < l; i++) {
145 | r = pre_a_pend(h)(g[i], v)(pv, ns);
146 | rs.push.call(rs, r.result);
147 | ns = r.state;
148 | }
149 | return { result: rs, state: ns };
150 | case 'function' :
151 | return core.chain(g, function(r) { return core.gen(h(r, pv)); })(pv, s);
152 | default :
153 | return { result: h(g, pv), state: s };
154 | }
155 | };
156 | };
157 | };
158 |
159 | /**
160 | * Prepends a value to the attribute value of the base object.
161 | * Prepend takes a value, an array or a generator as argument.
164 | * var o = { name : 'Head' }
165 | * generate({ name : prepend('Mr. Potato ') }, o) will generate:
166 | * [{ name : 'Mr. Potato Head' }]
167 | *
168 | *
169 | * @function {generator} prepend
170 | * @paramset Value
171 | * @param {any} inp - the value to prepend.
172 | * @paramset Array
173 | * @param {any[]} ar - the values to prepend. The resulting array
174 | * contains one object for every array element.
175 | * @paramset generator
176 | * @param {generator} gen - the generator of which result is prepended
177 | * to the base object value.
178 | */
179 | var prepend = lib.prepend = pre_a_pend(function(a, b) { return a + b; });
180 |
181 | /**
182 | * Appends a value to the attribute value of the base object.
183 | * See {@link prepend} for details.
184 | *
185 | * @function {generator} append
186 | * @paramset Value
187 | * @param {any} inp - the value to append.
188 | * @paramset Array
189 | * @param {any[]} ar - the values to append. The resulting array
190 | * contains one object for every array element.
191 | * @paramset generator
192 | * @param {generator} gen - the generator of which result is appended
193 | * to the base object value.
194 | */
195 | var append = lib.append = pre_a_pend(function(a, b) { return b + a; });
196 |
197 | // ------ Random generators extensions ------
198 |
199 | // Internal string generator builder.
200 | // Creates a generator for an argument char set,
201 | // see alpha and alphaNum.
202 | var randomString = function(char_set) {
203 | return function() {
204 | var mm = core.args2range(arguments, 1, 100),
205 | int = this.int(mm[0], mm[1]),
206 | element = this.element(char_set);
207 | return core.lazy(function(o, s) {
208 | var l = int().result, r = "";
209 | for (var i = 0; i < l; i++) {
210 | r += element().result;
211 | }
212 | return core.gen(r);
213 | });
214 | };
215 | };
216 |
217 | /** @scope Popcorn.Core.Random */
218 |
219 | /**
220 | * The range function 'alpha' generates a random alpha string.
221 | * The length of the string depends on the arguments this
222 | * function is called with.
223 | *
224 | * @function {generator} alpha
225 | * @paramset No arguments - generates an alpha string of length between 0 and 100.
226 | * @paramset One int argument - generates an alpha string of length between 0 and 'max'.
227 | * @param {integer} max - max string length.
228 | * @paramset two int arguments - length range.
229 | * @param {integer} min - min length
230 | * @param {integer} max - max length
231 | *
232 | * @see Popcorn.Utils.args2range
233 | */
234 | core.RandomLib.alpha = randomString(alpha);
235 |
236 | /**
237 | * Same as {@link alpha} but generates an alpha numeric string.
238 | *
239 | * @function {generator} alphaNum
240 | * @paramset No arguments - generates an alphaNum string of length between 0 and 100.
241 | * @paramset One int argument - generates an alphaNum string of length between 0 and 'max'.
242 | * @param {integer} max - max string length.
243 | * @paramset two int arguments - length range.
244 | * @param {integer} min - min length
245 | * @param {integer} max - max length
246 | *
247 | * @see Popcorn.Utils.args2range
248 | */
249 | core.RandomLib.alphaNum = randomString(alpha_num);
250 |
251 | /** @scope Popcorn.Common */
252 |
253 | /**
254 | * Date generator.
255 | *
256 | * @function {generator} date
257 | * @param {date} d - the JavaScript date object or a date string representation, for example 'Sep. 13 2009'.
258 | * @param {string} format - the output format, possible values are: date, hours, minutes, seconds, time, gmt.
259 | * By default date generates the local time string.
260 | */
261 | var date = lib.date = function(d, format) {
262 | var cdate = core.dateOf(d);
263 | switch(format) {
264 | case 'date' : return core.gen(cdate.getDate());
265 | case 'hours' : return core.gen(cdate.getHours());
266 | case 'minutes': return core.gen(cdate.getMinutes());
267 | case 'seconds': return core.gen(cdate.getSeconds());
268 | case 'time' : return core.gen(cdate.getTime());
269 | case 'gmt' : return core.gen(cdate.toString());
270 | default : return core.gen(cdate.toLocaleString());
271 | }
272 | };
273 |
274 | /**
275 | * A convenience function that creates a generator for current date/time.
276 | *
277 | * @function {generator} now
278 | * @param {string} format - the output format, possible values are: date, hours, minutes, seconds, time, gmt.
279 | * By default data prints the local time string.
280 | * @see Popcorn.Common.date
281 | */
282 | var now = lib.now = function(format) {
283 | return date(new Date(), format);
284 | };
285 |
286 | /**
287 | * Generates a random date
288 | *
289 | * @function {generator} date
290 | * @param {milisec} from - from date
291 | * @param {milisec} to - to date
292 | * @param {string} format - the output format, possible values are: date, hours, minutes, seconds, time, gmt.
293 | * By default data prints the local time string.
294 | *
295 | * @see Popcorn.Common.date
296 | */
297 | core.RandomLib.date = function(from, to, format) {
298 | var f = from || new Date(0),
299 | t = to || new Date(99999999999999),
300 | r = this;
301 | return core.lazy(function() { return lib.date(new Date(r.int(f.getTime(), t.getTime())().result), format); });
302 | };
303 |
304 | return lib;
305 |
306 | }(Popcorn.Core);
307 |
308 |
--------------------------------------------------------------------------------
/src/core.js:
--------------------------------------------------------------------------------
1 | /**
2 | * 'Core' module combines 'Utils' and 'Core' namespace.
3 | *
4 | * @module Popcorn.Core
5 | */
6 |
7 | /**
8 | * Root Popcorn namespace.
9 | *
10 | * @namespace Popcorn
11 | * @author Adam Smyczek
12 | */
13 | var Popcorn = Popcorn || {};
14 |
15 | // --------------------------------------------------------------------------
16 |
17 | /**
18 | * 'Utils' namespace contains helper functions used by all Popcorn modules.
19 | *
20 | * @namespace Popcorn.Utils
21 | * @author Adam Smyczek
22 | */
23 | Popcorn.Utils = function () {
24 |
25 | var lib = {};
26 |
27 | /**
28 | * Applies function 'f' on all elements of array 'as'. map(f, as) => [f(as[i])]
30 | *
31 | * @function {any[]} map
32 | * @param {function} f - function.
33 | * @param {any[]} as - input array.
34 | */
35 | var map = lib.map = function(f, as) {
36 | var ar = lib.arrayOf(as),
37 | l = as.length,
38 | r = [];
39 | for (var i = 0; i < l; i++) {
40 | r[i] = f(ar[i]);
41 | }
42 | return r;
43 | };
44 |
45 | var O = function() {};
46 | /**
47 | * Creates a new object with the argument objects as prototype.
48 | *
49 | * @function {object} clone
50 | * @param {object} o - the object to clone.
51 | */
52 | var clone = lib.clone = function(o) {
53 | O.prototype = o;
54 | return new O();
55 | };
56 |
57 | /**
58 | * Merges argument objects together.
59 | * This function copies all attributes of all argument
60 | * objects into one. Use with care, name conflicts are
61 | * not handled, attributes can be overwritten.
62 | *
63 | * @function {object} merge
64 | * @param {object+} os - one ore more objects to merge.
65 | */
66 | var merge = lib.merge = function() {
67 | var args = lib.args2array(arguments), r = {}, arg;
68 | for (var i = 0, l = args.length; i < l; i++) {
69 | arg = args[i];
70 | for (var name in arg) {
71 | if (arg.hasOwnProperty(name)) {
72 | r[name] = arg[name];
73 | }
74 | }
75 | }
76 | return r;
77 | };
78 |
79 | /**
80 | * Converts JavaScript function arguments to an array.
83 | * function() {
84 | * var args = args2array(arguments);
85 | * ...
86 | * }
87 | *
88 | *
89 | * @function {any[]} args2array
90 | * @param {arguments} args - the JavaScript function 'arguments'.
91 | */
92 | var args2array = lib.args2array = function(args) {
93 | return Array.prototype.slice.apply(args);
94 | };
95 |
96 | /**
97 | * Function arguments parser for 'range' functions.
111 | * function() {
112 | * var min_max = args2range(arguments);
113 | * ...
114 | * }
115 | *
116 | * @see Popcorn.Common.range for an example range function.
117 | *
118 | * @function {any[]} args2range
119 | * @param {arguments} args - the JavaScript function 'arguments'.
120 | * @param {integer} min - range min value used when no arguments are passed to the range function.
121 | * @param {integer} max - range max value used when no or one argument is passed to the range function.
122 | */
123 | var args2range = lib.args2range = function(args, min, max) {
124 | var a0 = min, a1 = max, as = args2array(args);
125 | switch(as.length) {
126 | case 1 : a1 = lib.intOf(as[0]);
127 | break;
128 | case 2 : a0 = lib.intOf(as[0]);
129 | a1 = lib.intOf(as[1]);
130 | break;
131 | }
132 | return [Math.min(a0, a1), Math.max(a0, a1)];
133 | };
134 |
135 | /**
136 | * 'typeOf' extends JavaScript 'typeof' operator with
137 | * support for 'null', 'undefined', 'array' and
138 | * 'date' types.
139 | * See 'Remedial JavaScript'
140 | * for more details.
141 | *
142 | * @function {string} typeOf
143 | * @param {any} inp - any variable, object etc.
144 | * @return a string representation of the type, for example 'null', 'array', 'data'.
145 | */
146 | var typeOf = lib.typeOf = function(inp) {
147 | if (inp === null) { return 'null'; }
148 | if (inp === undefined) { return 'undefined'; }
149 |
150 | var ot = typeof(inp);
151 | if (ot !== 'object') { return ot; }
152 | if ((typeof(inp.length) === 'number') &&
153 | !(inp.propertyIsEnumerable('length')) &&
154 | (typeof(inp.splice) === 'function')) {
155 | return 'array';
156 | }
157 | if (!isNaN (new Date(inp).getDate())) {
158 | return 'date';
159 | }
160 | return 'object';
161 | };
162 |
163 | /**
164 | * @function {boolean} isNull
165 | * @param {any} inp - any variable, object etc.
166 | * @return true if the input is null.
167 | */
168 | var isNull = lib.isNull = function(inp) {
169 | return typeOf(inp) === 'null';
170 | };
171 |
172 | /**
173 | * @function {boolean} isUndefined
174 | * @param {any} inp - any variable, object etc.
175 | * @return true if the input is undefined.
176 | */
177 | var isUndefined = lib.isUndefined = function(inp) {
178 | return typeOf(inp) === 'undefined';
179 | };
180 |
181 | /**
182 | * @function {boolean} isString
183 | * @param {any} inp - any variable, object etc.
184 | * @return true if the input is a string.
185 | */
186 | var isString = lib.isString = function(inp) {
187 | return typeOf(inp) === 'string';
188 | };
189 |
190 | /**
191 | * @function {boolean} isNumber
192 | * @param {any} inp - any variable, object etc.
193 | * @return true if the input is a number.
194 | */
195 | var isNumber = lib.isNumber = function(inp) {
196 | return typeOf(inp) === 'number';
197 | };
198 |
199 | /**
200 | * @function {boolean} isInt
201 | * @param {any} inp - any variable, object etc.
202 | * @return true if the input is an int.
203 | */
204 | var isInt = lib.isInt = function(inp) {
205 | try {
206 | var i = lib.numberOf(inp);
207 | return Math.floor(i) === i;
208 | } catch(e) {
209 | return false;
210 | }
211 | };
212 |
213 | /**
214 | * @function {boolean} isFunction
215 | * @param {any} inp - any variable, object etc.
216 | * @return true if the input is a function.
217 | */
218 | var isFunction = lib.isFunction = function(inp) {
219 | return typeOf(inp) === 'function';
220 | };
221 |
222 | /**
223 | * @function {boolean} isArray
224 | * @param {any} inp - any variable, object etc.
225 | * @return true if the input is an array.
226 | */
227 | var isArray = lib.isArray = function(inp) {
228 | return typeOf(inp) === 'array';
229 | };
230 |
231 | /**
232 | * @function {boolean} isDate
233 | * @param {any} inp - any variable, object etc.
234 | * @return true if the input is a date object.
235 | */
236 | var isDate = lib.isDate = function(inp) {
237 | return typeOf(inp) === 'date';
238 | };
239 |
240 | /**
241 | * @function {boolean} isObject
242 | * @param {any} inp - any variable, object etc.
243 | * @return true if the input is an object (not an array of function).
244 | */
245 | var isObject = lib.isObject = function(inp) {
246 | return typeOf(inp) === 'object';
247 | };
248 |
249 | /**
250 | * @function {string} stringOf
251 | * @param {any} inp - any variable, object etc.
252 | * @return the input object if it is a string and throws an exception otherwise.
253 | * @throws an exception if input is not a string.
254 | */
255 | var stringOf = lib.stringOf = function(inp) {
256 | if (!isString(inp)) {
257 | throw "Invalid input '" + inp + "', expecting a String!";
258 | }
259 | return inp;
260 | };
261 |
262 | /**
263 | * @function {number} numberOf
264 | * @param {any} inp - any variable, object etc.
265 | * @return the input object if it is a number and throws an exception otherwise.
266 | * @throws an exception if input is not a number.
267 | */
268 | var numberOf = lib.numberOf = function(inp) {
269 | if (!isNumber(inp)) {
270 | throw "Invalid input '" + inp + "', expecting a Number!";
271 | }
272 | return inp;
273 | };
274 |
275 | /**
276 | * 'intOf' truncates the input to an int if the input object is a number.
277 | * An exception is thrown when the input is not a number.
278 | *
279 | * @function {integer} intOf
280 | * @param {any} inp - any variable, object etc.
281 | * @return the input object if it is an int and throws an exception otherwise.
282 | * @throws an exception if input is not an int.
283 | */
284 | var intOf = lib.intOf = function(inp) {
285 | try {
286 | return Math.floor(numberOf(inp));
287 | } catch(e) {
288 | throw "Invalid input '" + inp + "', expecting an Integer!";
289 | }
290 | };
291 |
292 | /**
293 | * @function {function} functionOf
294 | * @param {any} inp - any variable, object etc.
295 | * @return the input object if it is a function and throws an exception otherwise.
296 | * @throws an exception if input is not a function.
297 | */
298 | var functionOf = lib.functionOf = function(inp) {
299 | if (!isFunction(inp)) {
300 | throw "Invalid input '" + inp + "', expecting a Function!";
301 | }
302 | return inp;
303 | };
304 |
305 | /**
306 | * @function {date} dateOf
307 | * @param {any} inp - any variable, object etc.
308 | * @return the input object if it is a date object or a date string.
309 | * @throws an exception if input is not a date object.
310 | */
311 | var dateOf = lib.dateOf = function(inp) {
312 | var d = (isString(inp))? new Date(Date.parse(inp)) : inp;
313 | if (!isDate(d)) {
314 | throw "Invalid input '" + inp + "', expecting an Date object or parsable date string!";
315 | }
316 | return d;
317 | };
318 |
319 | /**
320 | * @function {any[]} arrayOf
321 | * @param {any} inp - any variable, object etc.
322 | * @return the input object if it is an array and throws an exception otherwise.
323 | * @throws an exception if input is not an array.
324 | */
325 | var arrayOf = lib.arrayOf = function(inp) {
326 | if (!isArray(inp)) {
327 | throw "Invalid input '" + inp + "', expecting an Array!";
328 | }
329 | return inp;
330 | };
331 |
332 | return lib;
333 |
334 | }();
335 |
336 | // --------------------------------------------------------------------------
337 |
338 | /**
339 | * 'Core' namespace defines the basic generators for JavaScript primitive types
340 | * and objects.
376 | * var g = gen('test');
377 | * g('any input') will return 'test'.
378 | *
379 | *
380 | * @function {generator} gen
381 | * @param {any} inp - any variable, object etc.
382 | * @return a {@link generator} which executed returns the value 'v'.
383 | */
384 | var gen = lib.gen = function(v) {
385 | return function (_, s) { return { result: v, state: s }; };
386 | };
387 |
388 | /**
389 | * Use 'chain' to execute generators in sequence. 'chain'
390 | * executes the argument generator or generator array 'g'
391 | * and passes the result to the parameter function 'f'.
392 | * 'f' may evaluate the result but always has to return
393 | * a new generator. 'chain' itself is a generator that can
394 | * be evaluated or passed to another chain or other
395 | * generator function.
398 | * var g = chain(gen(1), function(r) { return gen(r + 1); });
399 | * g('any input') will evaluate to 2.
400 | *
401 | *
402 | * @function {generator} chain
403 | * @paramset
404 | * @param {generator} g - a {@link generator}
405 | * @param {function} f - a function that takes the result of the generator
406 | * 'g' and returns a new generator as result.
407 | *
408 | * @paramset
409 | * @param {generator[]} gs - {@link generator} array
410 | * @param {function} f - a function that takes the array result
411 | * of all generators 'gs' and returns a new generator as result.
412 | *
413 | * @return the 'chain' generator.
414 | */
415 | var chain = lib.chain = function(g, f) {
416 | return function(o, s) {
417 | var r, a;
418 | if (utils.isArray(g)) {
419 | r = lib.seq(g, lib.cConcat)(o, s);
420 | return f(r.result)(o, r.state);
421 | } else {
422 | r = g(o, s);
423 | a = f(r.result);
424 | return (utils.isArray(a))? lib.seq(a, lib.cConcat)(o, r.state) : a(o, r.state);
425 | }
426 | };
427 | };
428 |
429 | /**
430 | * 'seq' executes the generators 'gs' and combines the result using
431 | * {@link combinator} function 'f'. Combinator 'f' is called on every
432 | * step with the result of previous executions ('init' value on first call)
433 | * and the result of the current generator evaluation.
436 | * var g = seq([gen('a'), gen('b'), gen('c')], cJoin, 0);
437 | * g('any input') will return 'abc'.
438 | *
439 | *
440 | * @function {generator} seq
441 | * @param {generator[]} gs - {@link generator} array.
442 | * @param {combinator} f - {@link combinator} function.
443 | * @param {any} init - the initial value passed on first call to the {@link combinator}.
444 | *
445 | * @see Popcorn.Core.cConcat
446 | * @see Popcorn.Core.cJoin
447 | *
448 | * @return the sequence generator that evaluates the generators 'gs' when executed.
449 | */
450 | var seq = lib.seq = function(gs, f, init) {
451 | return function(o, s) {
452 | if (gs.length > 0) {
453 | var r = init, ns = s, ir;
454 | for (var i = 0, l = gs.length; i < l; i++) {
455 | ir = gs[i](o, ns);
456 | r = f(r, ir.result, i);
457 | ns = ir.state;
458 | }
459 | return { result: r, state: ns };
460 | }
461 | return { result: o, state: s };
462 | };
463 | };
464 |
465 | /**
466 | * Repeats value 'v' 'n'-times and returns the resulting array.
467 | * If parameter 'v' is an array, the subsequent results are concatenated.
468 | * 'repeat' is commonly used with object generators, for example:
469 | *
470 | * var gen = {
471 | * name : repeat(3, gen('abc'))
472 | * }
473 | * will generate three objects { name : 'abc' } when evaluated with {@link generate}.
474 | *
475 | * See {@link Popcorn.Core.generate} for details.
476 | *
477 | * @function {any[]} repeat
478 | * @param {integer} n - repeat count.
479 | * @param {any} v - object or generator to repeat.
480 | */
481 | var repeat = lib.repeat = function(n, v) {
482 | var c = Math.max(1, utils.intOf(n)),
483 | vs = [];
484 | if (utils.isArray(v)) {
485 | while (c--) { vs.push.apply(vs, v); }
486 | } else if (utils.isFunction(v)) {
487 | while (c--) { vs.push(v); }
488 | } else {
489 | while (c--) { vs.push(gen(v)); }
490 | }
491 | return vs;
492 | };
493 |
494 | /**
495 | * 'replicate' executes generator 'g' 'n'-times and combines
496 | * the results using {@link combinator} function 'f'.
497 | * This function is a specialization of {@link seq}.
500 | * var overflow = replicate(gen('A'), cJoin, '');
501 | * overflow(5) generates 'AAAAA'
502 | *
503 | *
504 | * @function {generator} replicate
505 | * @param {generator} g - a {@link generator}.
506 | * @param {combinator} f - {@link combinator} function.
507 | * @param {any} init - the initial value for the {@link combinator} function 'f'.
508 | * @see Popcorn.Core.seq
509 | * @return the replicator generator
510 | */
511 | var replicate = lib.replicate = function(g, f, init) {
512 | return function(n) {
513 | var c = Math.max(1, utils.intOf(n)),
514 | gs = [];
515 | for (var i = 0; i < c; i++) { gs[i] = g; }
516 | return seq(gs, f, init);
517 | };
518 | };
519 |
520 | /**
521 | * 'cConcat' {@link combinator} function concatenates the results
522 | * of generators executed in sequence into one array. 525 | * seq([gen(1), gen(2)], cConcat)() => [1,2] 526 | *527 | * 'cConcat' can be used in combination with {@link seq] and {@link replicate}. 528 | * 529 | * @function {any} cConcat 530 | * @param {any} r - combined result of previous executions. 531 | * @param {any} n - result of current generator evaluation. 532 | */ 533 | var cConcat = lib.cConcat = function(r, n) { return (r || []).concat(n); }; 534 | 535 | /** 536 | * 'cJoin' combinator function joins the results of generators 537 | * executed in sequence into one string.
540 | * seq([gen(1), gen(2)], cJoin)() => '12' 541 | *542 | * 'cJoin' can be used in combination with {@link seq] and {@link replicate}. 543 | * 544 | * @function {any} cJoin 545 | * @param {any} r - combined result of previous executions. 546 | * @param {any} n - result of current generator evaluation. 547 | */ 548 | var cJoin = lib.cJoin = function(r, n) { return (r || '') + n; }; 549 | 550 | // ------ Handling objects ------ 551 | 552 | /** 553 | * 'property' applies generator 'g' on an object property of name 554 | * 'name' and returns the resulting object. 'property' acts as a 555 | * property selector and is a generator itself that can be 556 | * evaluated or passed to other generators.
559 | * var o = { name:'Woody', toy:'cowboy' };
560 | * var name = property('name');
561 | * name(gen('Buzz'))(o) will return the object { name:'Buzz', toy:'cowboy' }
562 | *
563 | *
564 | * @function {generator} property
565 | * @param {string} name - object property name.
566 | */
567 | var property = lib.property = function(name) {
568 | return function(g) {
569 | return function(o, s) {
570 | var r = g(o[name]);
571 | o[name] = r.result;
572 | return { result: o, state: r.state };
573 | };
574 | };
575 | };
576 |
577 | /**
578 | * Executes generators 'gs' on an input object
579 | * and returns the updated object.
582 | * var o = { name: 'Woody', toy: 'cowboy' };
583 | * var name = property('name');
584 | * var toy = property('toy');
585 | * update([name(gen('Buzz')), toy(gen('action figure'))])(o) will return the object
586 | * { name:'Buzz', toy:'action figure' }
587 | *
588 | *
589 | * @function {generator} update
590 | * @param {generator[]} gs - {@link generator} array.
591 | */
592 | var update = lib.update = function(gs) {
593 | return seq(gs, function(r, n) { return r || n; });
594 | };
595 |
596 | /**
597 | * 'mutate' executes generators 'gs' on the input object o.
598 | * For example:
599 | *
600 | * mutate([gen('Buzz'), gen('Woody')](o) will return
601 | * ['Buzz', 'Woody']
602 | *
603 | * @function {generator} mutate
604 | * @param {generator[]} gs - {@link generator} array.
605 | */
606 | var mutate = lib.mutate = function(gs) {
607 | return function(o, s) {
608 | if (gs.length > 0) {
609 | var r = [], ns = s, ogr;
610 | for(var i = 0, l = gs.length; i < l; i++) {
611 | var gr = gs[i](o, ns);
612 | ns = gr.state;
613 |
614 | // Mutate on an array
615 | if (utils.isArray(gr.result)) {
616 | for (var j = 0, jl = gr.result.length; j < jl; j++) {
617 | r.push(gr.result[j]);
618 | }
619 |
620 | // Mutate on a group generator
621 | } else if (utils.isObject(gr.result) && (gr.result._array_result === true)) {
622 | ogr = (utils.isArray(gr.result._generator))?
623 | seq(gr.result._generator, cConcat)(o, ns) :
624 | gr.result._generator(o, ns);
625 | ns = ogr.state;
626 | r.push((gr.result._join_result === true)? ogr.result : ogr.result.join());
627 |
628 | // Mutate on an inner-object
629 | // TODO currently supported for permutation only
630 | } else if (utils.isObject(gr.result)) {
631 | if (MODE_PERMUTATE === ns._generation_mode) {
632 | ogr = lib.permutate(gr.result, o, -1, ns, id);
633 | ns = ogr.state;
634 | for (var k = 0, kl = ogr.result.length; k < kl; k++) {
635 | r.push(ogr.result[k]);
636 | }
637 | } else {
638 | r.push(gr.result);
639 | }
640 |
641 | // All other values
642 | } else {
643 | r.push(gr.result);
644 | }
645 | }
646 | return { result: r, state: ns };
647 | }
648 | return { result: [o], state: s };
649 | };
650 | };
651 |
652 | // New object constructor function used for object
653 | // 'mutateOnAttribute' and 'permutate' functions.
654 | var O = function() {};
655 |
656 | /**
657 | * 'mutateOnAttribute' executes generators 'gs' on an object property
658 | * of name 'name'. The result is an array that contains
659 | * one result object for every generator result value.
662 | * var o = { name: 'Woody', age:2 };
663 | * mutateOnAttribute('name', [gen('Buzz'), gen('Woody')](o) will return
664 | * the object array [{ name:'Buzz', age:2 }, { name:'Woody', age:2 }]
665 | *
666 | *
667 | * @function {generator} mutateOnAttribute
668 | * @param {string} name - object property name.
669 | * @param {generator[]} gs - {@link generator} array.
670 | */
671 | var mutateOnAttribute = function(name, gs) {
672 | return function(o, s) {
673 | if (gs.length > 0) {
674 | var gr = mutate(gs)(o[name], s),
675 | rs = gr.result,
676 | r = [], n;
677 | for (var j = 0, jl = rs.length; j < jl; j++) {
678 | O.prototype = o;
679 | n = new O();
680 | n[name] = rs[j];
681 | r.push(n);
682 | }
683 | return { result: r, state: gr.state };
684 | }
685 | return { result: [o], state: s };
686 | };
687 | };
688 |
689 | /**
690 | * Wrappes a value into generator array,
691 | * the default input for 'mutate'.
692 | *
693 | * @function {generator[]} toGenArray
694 | * @param {value/generator/[generator]} value
695 | */
696 | var toGenArray = function(v) {
697 | if (utils.isArray(v)) {
698 | return v;
699 | } else if (utils.isFunction(v)) {
700 | return [v];
701 | } else {
702 | return [gen(v)];
703 | }
704 | };
705 |
706 | // ------ JSON object generation functions ------
707 |
708 | /**
709 | * 'permutate' is one of two supported JSON object
710 | * generation functions. It executes the argument
711 | * generator 'gen' on the default object 'base'
712 | * and returns the resulting object array.
716 | * var base = { name: 'Woody', age:2 };
717 | * var gen = { name: list('Buzz', 'Slinky'), age: range(2,4) };
718 | * generate(gen, base) will return the array:
719 | * [{ name: 'Buzz', age: 2 },
720 | * { name: 'Buzz', age: 3 },
721 | * { name: 'Buzz', age: 4 },
722 | * { name: 'Slinky', age: 2 },
723 | * { name: 'Slinky', age: 3 },
724 | * { name: 'Slinky', age: 4 }]
725 | *
726 | *
727 | * @function {object[]} permutate
728 | * @param {object} gen - the generator object.
729 | * @param {object} base - the base test case object.
730 | * @param {int} count - an optional result count
731 | * @param {object} state - an optional state object that
732 | * can be read and manipulated by any generator.
733 | * @param {function} result_transformer - an optional function
734 | * which takes the result generator object { result:r, state:s }
735 | * as argument and returns the desired result. If not defined,
736 | * the default transformer returns just the result array.
737 | * To return the result and state use 'id' function.
738 | */
739 | var permutate = lib.permutate = function(generator, base, count, state, result_transformer) {
740 | var st = state || {};
741 | var c = count || -1;
742 | var rt = result_transformer || function(r) { return r.result; };
743 | var gs = [], rs = [], r;
744 | st._generation_mode = MODE_PERMUTATE;
745 |
746 | // Recursive permutate helper applies
747 | // generator 'g' on all objects 'os'.
748 | var perm_rec = function(g, os, s) {
749 | var rs = [], rr, ns = s, r, o;
750 | for (var i = 0, l = os.length; i < l; i++) {
751 | O.prototype = os[i];
752 | o = new O();
753 | ns._result_object = o;
754 | r = g(o, ns);
755 | ns = r.state;
756 | rs.push.apply(rs, r.result);
757 | }
758 | return { result: rs, state: ns };
759 | };
760 |
761 | // Permutate generator
762 | var perm_gen = function(o, s) {
763 | if (gs.length > 0) {
764 | var rs = [o], ns = s, r;
765 | for (var i = 0, l = gs.length; i < l; i++) {
766 | r = perm_rec(gs[i], rs, ns);
767 | ns = r.state;
768 | rs = r.result;
769 | }
770 | return { result: rs, state: ns };
771 | }
772 | return { result: [o], state: s };
773 | };
774 |
775 | // Generation
776 | for (var name in generator) {
777 | if (generator.hasOwnProperty(name)) {
778 | gs.push(mutateOnAttribute(name, toGenArray(generator[name])));
779 | }
780 | }
781 |
782 | // TODO: move count logic into the permutate generator
783 | // XXX: state does not match the result of the last run
784 | // if n x run > count !!!
785 | var done = false;
786 | while(!done) {
787 | r = perm_gen(base, st);
788 | rs = rs.concat(r.result);
789 | st = r.state;
790 | if (c < 0) {
791 | done = true;
792 | } else if (rs.length > c) {
793 | rs = rs.slice(0, c);
794 | done = true;
795 | }
796 | }
797 |
798 | return rt({ result : rs, state : st });
799 | };
800 |
801 | /**
802 | * Same as 'permutate', 'circulate' executes the argument
803 | * generator 'gen' on the default object 'base'
804 | * and returns the resulting object array.
811 | * var base = { name: 'Woody', age:2 };
812 | * var gen = { name: list('Buzz', 'Slinky'), age: range(2,5) };
813 | * generate(gen, base) will return the array:
814 | * [{ name: 'Buzz', age: 2 },
815 | * { name: 'Slinky', age: 3 },
816 | * { name: 'Buzz', age: 4 },
817 | * { name: 'Slinky', age: 5 }]
818 | *
819 | *
820 | * @function {object[]} circulate
821 | * @param {object} gen - the generator object.
822 | * @param {object} base - the base test case object.
823 | * @param {int} count - an optional result count
824 | * @param {object} state - an optional state object that
825 | * can be read and manipulated by any generator.
826 | * @param {function} result_transformer - an optional function
827 | * which takes the result generator object { result:r, state:s }
828 | * as argument and returns the desired result. If not defined,
829 | * the default transformer returns just the result array.
830 | * To return the result and state use 'id' function.
831 | */
832 | var circulate = lib.circulate = function(generator, base, count, state, result_transformer) {
833 | var s = state || {};
834 | var c = count || -1;
835 | var rt = result_transformer || function(r) { return r.result; };
836 | s._generation_mode = MODE_CIRCULATE;
837 | s._result_object = base;
838 |
839 | var gs = {}, gr = {}, r, o, max = 0, rs = [], name;
840 |
841 | // Initialize
842 | for (name in generator) {
843 | if (generator.hasOwnProperty(name)) {
844 | gs[name] = mutate(toGenArray(generator[name]));
845 | r = gs[name](base[name], s);
846 | if (r.result.length > max) { max = r.result.length; }
847 | gr[name] = [];
848 | }
849 | }
850 |
851 | // Generate
852 | max = (c < 0)? max : c;
853 | while(max > 0) {
854 | max--;
855 | O.prototype = base;
856 | o = new O();
857 | s._result_object = o;
858 | for (name in generator) {
859 | if (generator.hasOwnProperty(name)) {
860 | if (gr[name].length === 0) {
861 | r = gs[name](base[name], s);
862 | gr[name] = r.result;
863 | s = r.state;
864 | }
865 | o[name] = gr[name].shift();
866 | }
867 | }
868 | rs.push(o);
869 | }
870 |
871 | return rt({ result : rs, state : s });
872 | };
873 |
874 | /**
875 | * 'current' provides access to current generated object.
876 | * It's experimental, use with care!!!
877 | * For example:
878 | *
879 | * var o = { name: 'Woody', age:2 };
880 | * var g = { name : list('Buzz', 'Woody'),
881 | * description : current(function(r) { return r.name + ' is ' + r.age; }) }
882 | * permutate(g, o) will return
883 | * [{ name:'Buzz', age:2, description: 'Buzz is 2' },
884 | * { name:'Woody', age:2, description: 'Woody is 2' }]
885 | *
886 | *
887 | * @function {generator} current
888 | * @param {function} f - a callback function that takes the current
889 | * generated objects as parameter and returns
890 | * this attribute value.
891 | */
892 | var current = lib.current = function(f) {
893 | return function(o, s) {
894 | return { result : f(s._result_object), state : s };
895 | };
896 | };
897 |
898 | /**
899 | * Equivalent to 'permutate'.
900 | * @Deprecated
901 | */
902 | var generate = lib.generate = function(generator, base, state, result_transformer) {
903 | return permutate(generator, base, -1, state, result_transformer);
904 | };
905 |
906 | // ------ State and variables ------
907 |
908 | /**
909 | * 'setVar' stores the result of one generator that can be used
910 | * as input to another generator in same generation process.
914 | * var g = {
915 | * int : setVar('my_rand', random().int()),
916 | * plus1 : withVar('my_rand', function(i) { return gen(i + 1); })
917 | * }
918 | *
919 | *
920 | * The random integer value generated for attribute 'int' is stored
921 | * in the state object under the attribute name 'my_rand' and referenced
922 | * using {@link withVar} function.
923 | *
924 | * @function {generator} setVar
925 | * @param {string} name - variable name the generator value is stored for.
926 | * @param {generator} g - the generator to execute.
927 | * @return result of the generator 'g'.
928 | */
929 | var setVar = lib.setVar = function(name, g) {
930 | return function(o, s) {
931 | var r = g(o, s);
932 | r.state[name] = r.result;
933 | return gen(r.result)(o, r.state);
934 | };
935 | };
936 |
937 | /**
938 | * 'withVar' provides access to variables stored using {@link setVar}
939 | * generator. It takes the variable name and a function as argument.
940 | * The value of the variable is passed to the function that has
941 | * to return another generator as result.
942 | * For an example see {@link setVar} generator.
943 | *
944 | * @function {generator} withVar
945 | * @param {string} name - variable name.
946 | * @param {function} f - takes the variable as argument and returns
947 | * a new generator as result.
948 | */
949 | var withVar = lib.withVar = function(name, f) {
950 | return function (o, s) {
951 | return f(s[name])(o, s);
952 | };
953 | };
954 |
955 | /**
956 | * Creates a generator that returns the value of the
957 | * variable 'name' when executed. For example:
958 | *
959 | *
960 | * var g = {
961 | * att1 : setVar('my_rand', random().int()),
962 | * att2 : varGen('my_rand')
963 | * }
964 | *
965 | * will generate an object with same value for
966 | * both attributes.
967 | *
968 | * @function {generator} varGen
969 | * @param {string} name - variable name.
970 | */
971 | var varGen = lib.varGen = function(name) {
972 | return function (o, s) {
973 | return gen(s[name])(o, s);
974 | };
975 | };
976 |
977 | /**
978 | * 'withState' provides access to the state object.
979 | * The function 'f' takes the state object as argument
980 | * and returns another generator as result. All modifications
981 | * to the state object are visible to other generators.
982 | * For example:
983 | *
984 | *
985 | * var g = {
986 | * int : withState(function(s) { s.init = 10; return random().int(); } ),
987 | * add : withState(function(s) { return gen(s.init + 10); } )
988 | * }
989 | *
990 | *
991 | * @function {generator} withState
992 | * @param {function} f - takes the state object as argument and
993 | * returns a new generator as result.
994 | */
995 | var withState = lib.withState = function(f) {
996 | return function (o, s) {
997 | return f(s)(o, s);
998 | };
999 | };
1000 |
1001 | /**
1002 | * Group generator results into array
1003 | *
1004 | * @function {generator} array
1005 | * @param {function} g - the generator to wrap
1006 | */
1007 | // A work-around for not supporting seq-monad yet!
1008 | var array = lib.array = function(g) {
1009 | return gen({ _array_result : true, _generator : g });
1010 | };
1011 |
1012 | // ------ Core random generators ------
1013 |
1014 | /**
1015 | * Creates a linear congruential random generator object using an optional
1016 | * 'seed' value. If 'seed' is not defined, the default JavaScript Math.random()
1017 | * function is used. See Wikipedia
1018 | * LCR
1019 | * for details.
1020 | *
1021 | * @function {random} random
1022 | * @param {integer} seed - an optional seed.
1023 | * @return the random generator object.
1024 | */
1025 | var random = lib.random = function(seed) {
1026 | var m = 4294967296, // 2^32
1027 | a = 1103515245, // glibc conform multiplier
1028 | c = 12345, // and increment
1029 | s = seed || Math.floor(Math.random() * m),
1030 | x = s % m;
1031 |
1032 | // Moves to the next pseudo-random value in the sequence
1033 | // and generates next int in the range from min to max.
1034 | var nextInt = function(min, max) {
1035 | x = (a * x + c) % m;
1036 | return Math.floor(min + x/m * (max - min));
1037 | };
1038 |
1039 | /**
1040 | * Random generator object.
1041 | * This object implements all {@link Popcorn.Core.RandomLib}
1042 | * generator functions.
1043 | *
1044 | * @object Popcorn.Core.Random
1045 | */
1046 | var rand = utils.clone(lib.RandomLib);
1047 |
1048 | /**
1049 | * A random integer generator. 'int' is a rage function
1050 | * that generates a value between min and max, depending
1051 | * on arguments the function is called with.
1052 | *
1053 | * @function {generator} int
1054 | * @paramset No arguments - the generator returns a random value between 0 and 100.
1055 | * @paramset One int argument - the generator returns a random value between 0 and max.
1056 | * @param {integer} max - max value.
1057 | * @paramset Two int argument - the generator returns a random value between min and max.
1058 | * @param {integer} min - from integer
1059 | * @param {integer} max - to integer
1060 | * @return a generator which executed generates a random integer.
1061 | */
1062 | rand.int = function() {
1063 | var mm = utils.args2range(arguments, 0, 1000);
1064 | return lib.lazy(function() { return gen(nextInt(mm[0], mm[1])); });
1065 | };
1066 |
1067 | /**
1068 | * 'element' picks a random element from provided argument array 'as'.
1069 | *
1070 | * @function {generator} element
1071 | * @param {any[]} as - array
1072 | * @return the element generator which executed returns a random element
1073 | * from argument array 'as'.
1074 | */
1075 | rand.element = function(as) {
1076 | if (as.length > 0) {
1077 | return lib.lazy(function() { return gen(as[nextInt(0, as.length)]); });
1078 | }
1079 | throw "Empty array or string!";
1080 | };
1081 |
1082 | return rand;
1083 | };
1084 |
1085 | /**
1086 | * Extensible library class for random generators.
1087 | * 'RandomLib' can be extended by other modules as following:
1088 | *
1089 | * core.RandomLib.randomAlpha = function() {...};
1090 | *
1091 | * Once the module is loaded, 'randomAlpha' is available
1092 | * in the {@link Random} object and can be executed as:
1093 | * 1094 | * random().randomAlpha(); 1095 | *1096 | * 1097 | * @class Popcorn.Core.RandomLib 1098 | * @see Popcorn.Common.alpha 1099 | */ 1100 | var RandomLib = lib.RandomLib = {}; 1101 | 1102 | // ------ Other generator functions ------ 1103 | 1104 | /** @scope Popcorn.Core */ 1105 | 1106 | /** 1107 | * Lazy generator evaluation wrapper 1108 | * used for example by random generators.
1111 | * var g1 = gen(Math.random());
1112 | * var g2 = lazy(function() { return gen(Math.random()); });
1113 | * g1 will always return the same value and g2 a different one
1114 | * when executed.
1115 | *
1116 | *
1117 | * @function {generator} lazy
1118 | * @param g - the {@link generator} to wrap.
1119 | */
1120 | var lazy = lib.lazy = function(g) {
1121 | return function(o, s) { return g(o, s)(o, s); };
1122 | };
1123 |
1124 | /**
1125 | * 'mapGen' is a helper function that
1126 | * converts all elements of an array to
1127 | * generators. magGen(as) -> [gen(as[i])]
1129 | *
1130 | * @function {generator[]} mapGen
1131 | * @param {any[]} vs - array.
1132 | */
1133 | var mapGen = lib.mapGen = function(vs) {
1134 | return utils.map(gen, vs);
1135 | };
1136 |
1137 | return lib;
1138 |
1139 | }(Popcorn.Utils);
1140 |
1141 |
--------------------------------------------------------------------------------
/src/dictionary.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @module Popcorn.Dictionary
3 | * @requires Popcorn.Core
4 | */
5 |
6 | /**
7 | * Base functions and objects to build dictionaries.
8 | *
9 | * @namespace Popcorn.Dictionary
10 | * @author Adam Smyczek
11 | * @author Brian Wilkerson
12 | */
13 | Popcorn.Dictionary = function (core) {
14 |
15 | var lib = {};
16 |
17 | /**
18 | * Creates a {@link Dict} object for an dictionary array. 21 | * The pronouns dictionary 22 | * var pronoun = dictionary(['I', 'you', 'he', 'she', 'it']); 23 | * provides generators: 24 | * pronoun.list(), pronoun.element(), etc. 25 | *26 | * 27 | * @function {object} dictionary 28 | * @param {any[]} dict - a dictionary array. 29 | * @return a dictionary object. 30 | */ 31 | var dictionary = lib.dictionary = function(dict) { 32 | 33 | /** 34 | * A base dictionary object provides common 35 | * generators for array dictionaries. 36 | * 37 | * @object Popcorn.Dictionary.Dict 38 | */ 39 | return { 40 | 41 | /** 42 | * Creates a generator to list dictionary elements. 43 | * By default all dictionary elements are listed. If 'n' > dict.length 44 | * the resulting elements are repeated in loop. 45 | * 'list' is a range function that takes no arguments, or 46 | * one or two integer arguments. 47 | * 48 | * @function {generator} list 49 | * @paramset No arguments - the generator returns the entire dictionary. 50 | * @paramset One int argument - the generator returns the first n elements. 51 | * @param {integer} n - element count. 52 | * @paramset two int arguments - the generator returns elements from n to m 53 | * @param {integer} n - from list index 54 | * @param {integer} m - to list index 55 | * 56 | * @see Popcorn.Utils.args2range 57 | */ 58 | list : function() { 59 | var mm = core.args2range(arguments, 0, dict.length), 60 | ar = dict, r = []; 61 | while (ar.length < mm[1]) { 62 | ar.push.apply(ar, dict); 63 | } 64 | for (var i = 0, l = mm[1] - mm[0]; i < l; i++) { 65 | r[i] = core.gen(ar[mm[0] + i]); 66 | } 67 | return r; 68 | }, 69 | 70 | /** 71 | * 'element' returns one random dictionary element. 72 | * This generator uses a random generator 'rand' if 73 | * provided, otherwise creates a new {@link Popcorn.Core.random} 74 | * generator. 75 | * 76 | * @function {generator} element 77 | * @param {random} rand - a random generator 'random()'. 78 | * 79 | * @see Popcorn.Core.random 80 | */ 81 | element : function(rand) { 82 | var r = rand || core.random(); 83 | return core.lazy(function() { return r.element(dict); }); 84 | }, 85 | 86 | /** 87 | * 'elements' returns n random dictionary element. 88 | * 89 | * @function {generator} elements 90 | * @param {integer} n - element count to generate 91 | * @param {random} rand - optional a random generator 'random()'. 92 | * 93 | * @see Popcorn.Core.random 94 | */ 95 | elements : function(n, rand) { 96 | var c = n || 5, 97 | r = rand || core.random(); 98 | return core.repeat(c, r.element(dict)); 99 | } 100 | 101 | }; 102 | 103 | }; 104 | 105 | // ------ Lorem ipsum ------ 106 | 107 | var lorem_ipsum = [ 108 | 'Lorem', 'ipsum', 'dolor', 'sit', 'amet,', 'consectetur', 'adipisicing', 'elit,', 109 | 'sed', 'do', 'eiusmod', 'tempor', 'incididunt', 'ut', 'labore', 'et', 'dolore', 110 | 'magna', 'aliqua.', 'Ut', 'enim', 'ad', 'minim', 'veniam,', 'quis', 'nostrud', 111 | 'exercitation', 'ullamco', 'laboris', 'nisi', 'ut', 'aliquip', 'ex', 'ea', 112 | 'commodo', 'consequat.', 'Duis', 'aute', 'irure', 'dolor', 'in', 'reprehenderit', 113 | 'in', 'voluptate', 'velit', 'esse', 'cillum', 'dolore', 'eu', 'fugiat', 'nulla', 114 | 'pariatur.', 'Excepteur', 'sint', 'occaecat', 'cupidatat', 'non', 'proident,', 115 | 'sunt', 'in', 'culpa', 'qui', 'officia', 'deserunt', 'mollit', 'anim', 'id', 116 | 'est', 'laborum.']; 117 | 118 | /** @scope Popcorn.Dictionary */ 119 | 120 | /** 121 | * Generate a lorem ipsum 122 | * content of the length 'n'. 123 | * This function returns the lorem ipsum if 'n' is not defined. 124 | * 125 | * @function {generator} loremIpsum 126 | * @param {integer} n - optional length of the generated lorem ipsum content. 127 | * @param {integer} m - optional min/max length randomly chosen. 128 | */ 129 | var loremIpsum = lib.loremIpsum = function(n) { 130 | var l = n || lorem_ipsum.length; 131 | return core.gen(lorem_ipsum.slice(0, l).join(" ")); 132 | }; 133 | 134 | /** 135 | * Random length lorem ipsum generator. 136 | * 137 | * @function {generator[int]} loremIpsum 138 | * @paramset No arguments - generates a range from 0 to lorem ipsum length 139 | * @paramset One int argument - generates a range from 0 to lorem ipsum length. 140 | * @param {integer} max - range max value. 141 | * @paramset two int arguments - from-to range. 142 | * @param {integer} min - from integer 143 | * @param {integer} max - to integer 144 | * 145 | * @see Popcorn.Core.random 146 | */ 147 | core.RandomLib.loremIpsum = function() { 148 | var mm = core.args2range(arguments, 0, lorem_ipsum.length); 149 | return core.gen(lorem_ipsum.slice(mm[0], mm[0] + this.int(mm[0], mm[1])().result).join(" ")); 150 | }; 151 | 152 | return lib; 153 | 154 | }(Popcorn.Core); 155 | 156 | -------------------------------------------------------------------------------- /src/names.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @module Popcorn.Names 3 | * @requires Popcorn.Core 4 | * @requires Popcorn.Dictionary 5 | */ 6 | 7 | /** 8 | * Most common English names and surnames dictionaries.
17 | * with({ core: Popcorn.Core,
18 | * comm: Popcorn.Common }) { // Load other modules as needed.
19 | *
20 | * var base_object = { // Define the base object.
21 | * id : 1,
22 | * name : 'Woody'
23 | * };
24 | *
25 | * var generator = { // Define the generator object.
26 | * id : core.range(10, 20),
27 | * name : comm.list('Buzz', 'Slinky')
28 | * };
29 | *
30 | * // And run it!
31 | * var results = core.generate(generator, base_object);
32 | * }
33 | *
54 | * {
55 | * result: value,
56 | * state : state_obj
57 | * }
58 | * 14 |
20 |
48 |
13 |
19 |
36 |
57 |
89 |
106 |
16 |
22 |
41 |
55 |
16 |
22 |
38 |