conjur-asset-ui-api 1.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (114) hide show
  1. checksums.yaml +7 -0
  2. data/.git-hooks/pre_commit/ensure_livescript_compiled.rb +31 -0
  3. data/.git-hooks/pre_commit/trailing_whitespace.rb +26 -0
  4. data/.gitignore +20 -0
  5. data/.overcommit.yml +5 -0
  6. data/.project +18 -0
  7. data/Gemfile +8 -0
  8. data/LICENSE.txt +22 -0
  9. data/README.md +41 -0
  10. data/Rakefile +1 -0
  11. data/compile_ls +2 -0
  12. data/conjur-asset-ui.gemspec +36 -0
  13. data/lib/conjur-asset-ui-version.rb +7 -0
  14. data/lib/conjur-asset-ui.rb +7 -0
  15. data/lib/conjur/audit/follower.rb +63 -0
  16. data/lib/conjur/audit/humanizer.rb +53 -0
  17. data/lib/conjur/audit/tableizer.rb +55 -0
  18. data/lib/conjur/command/ui.rb +38 -0
  19. data/lib/conjur/webserver/api_proxy.rb +94 -0
  20. data/lib/conjur/webserver/audit_stream.rb +92 -0
  21. data/lib/conjur/webserver/authorize.rb +28 -0
  22. data/lib/conjur/webserver/conjur_info.rb +33 -0
  23. data/lib/conjur/webserver/home.rb +36 -0
  24. data/lib/conjur/webserver/login.rb +50 -0
  25. data/lib/conjur/webserver/server.rb +111 -0
  26. data/livescript/views/audit.ls +124 -0
  27. data/public/css/bootstrap.css +7 -0
  28. data/public/css/styles.less +400 -0
  29. data/public/fonts/glyphicons-halflings-regular.eot +0 -0
  30. data/public/fonts/glyphicons-halflings-regular.svg +229 -0
  31. data/public/fonts/glyphicons-halflings-regular.ttf +0 -0
  32. data/public/fonts/glyphicons-halflings-regular.woff +0 -0
  33. data/public/images/conjur-logo.svg +26 -0
  34. data/public/images/icon-client-pc.svg +12 -0
  35. data/public/images/icon-environment.png +0 -0
  36. data/public/images/icon-person.svg +12 -0
  37. data/public/images/icon-service-dots.svg +13 -0
  38. data/public/images/icon-variable.png +0 -0
  39. data/public/index.html +121 -0
  40. data/public/js/lib/JSXTransformer.js +10862 -0
  41. data/public/js/lib/async.js +958 -0
  42. data/public/js/lib/backbone.js +2 -0
  43. data/public/js/lib/bootstrap.js +6 -0
  44. data/public/js/lib/date.extensions.js +141 -0
  45. data/public/js/lib/less.js +16 -0
  46. data/public/js/lib/moment.js +7768 -0
  47. data/public/js/lib/pace.js +2 -0
  48. data/public/js/lib/prelude-browser-min.js +1 -0
  49. data/public/js/lib/react-with-addons.js +15505 -0
  50. data/public/js/lib/react.js +14469 -0
  51. data/public/js/lib/sorted-set.no-require.js +1170 -0
  52. data/public/js/lib/sorted-set.no-require.js.txt +6 -0
  53. data/public/js/lib/underscore-min.js +6 -0
  54. data/public/js/lib/underscore.string.min.js +1 -0
  55. data/public/js/main.js +353 -0
  56. data/public/js/models/namespace.js +6 -0
  57. data/public/js/models/policyList.js +10 -0
  58. data/public/js/models/record.js +26 -0
  59. data/public/js/models/resourceList.js +61 -0
  60. data/public/js/models/userList.js +16 -0
  61. data/public/js/models/variableList.js +12 -0
  62. data/public/js/views/audit.js +191 -0
  63. data/public/js/views/dashboard.js +35 -0
  64. data/public/js/views/generic.js +42 -0
  65. data/public/js/views/group.js +32 -0
  66. data/public/js/views/groups.js +18 -0
  67. data/public/js/views/host.js +40 -0
  68. data/public/js/views/hosts.js +18 -0
  69. data/public/js/views/layer.js +63 -0
  70. data/public/js/views/layers.js +18 -0
  71. data/public/js/views/mixins/search.js +9 -0
  72. data/public/js/views/namespaces.js +40 -0
  73. data/public/js/views/navSearch.js +16 -0
  74. data/public/js/views/permissions.js +91 -0
  75. data/public/js/views/policies.js +17 -0
  76. data/public/js/views/policy.js +23 -0
  77. data/public/js/views/resource.js +23 -0
  78. data/public/js/views/role.js +18 -0
  79. data/public/js/views/searchResults.js +146 -0
  80. data/public/js/views/time.js +14 -0
  81. data/public/js/views/user.js +22 -0
  82. data/public/js/views/users.js +18 -0
  83. data/public/js/views/variable.js +41 -0
  84. data/public/js/views/variables.js +18 -0
  85. data/vendor/prelude-ls/.gitignore +2 -0
  86. data/vendor/prelude-ls/.travis.yml +3 -0
  87. data/vendor/prelude-ls/CHANGELOG.md +81 -0
  88. data/vendor/prelude-ls/LICENSE +22 -0
  89. data/vendor/prelude-ls/Makefile +50 -0
  90. data/vendor/prelude-ls/README.md +15 -0
  91. data/vendor/prelude-ls/browser/prelude-browser-min.js +1 -0
  92. data/vendor/prelude-ls/browser/prelude-browser.js +1172 -0
  93. data/vendor/prelude-ls/lib/Func.js +40 -0
  94. data/vendor/prelude-ls/lib/List.js +602 -0
  95. data/vendor/prelude-ls/lib/Num.js +129 -0
  96. data/vendor/prelude-ls/lib/Obj.js +153 -0
  97. data/vendor/prelude-ls/lib/Str.js +68 -0
  98. data/vendor/prelude-ls/lib/index.js +164 -0
  99. data/vendor/prelude-ls/package.json +50 -0
  100. data/vendor/prelude-ls/package.ls +46 -0
  101. data/vendor/prelude-ls/src/Func.ls +17 -0
  102. data/vendor/prelude-ls/src/List.ls +299 -0
  103. data/vendor/prelude-ls/src/Num.ls +83 -0
  104. data/vendor/prelude-ls/src/Obj.ls +61 -0
  105. data/vendor/prelude-ls/src/Str.ls +32 -0
  106. data/vendor/prelude-ls/src/index.ls +56 -0
  107. data/vendor/prelude-ls/test/Func.ls +36 -0
  108. data/vendor/prelude-ls/test/List.ls +751 -0
  109. data/vendor/prelude-ls/test/Num.ls +258 -0
  110. data/vendor/prelude-ls/test/Obj.ls +145 -0
  111. data/vendor/prelude-ls/test/Prelude.ls +49 -0
  112. data/vendor/prelude-ls/test/Str.ls +208 -0
  113. data/vendor/prelude-ls/test/browser.html +5 -0
  114. metadata +328 -0
@@ -0,0 +1,958 @@
1
+ /*global setImmediate: false, setTimeout: false, console: false */
2
+ (function () {
3
+
4
+ var async = {};
5
+
6
+ // global on the server, window in the browser
7
+ var root, previous_async;
8
+
9
+ root = this;
10
+ if (root != null) {
11
+ previous_async = root.async;
12
+ }
13
+
14
+ async.noConflict = function () {
15
+ root.async = previous_async;
16
+ return async;
17
+ };
18
+
19
+ function only_once(fn) {
20
+ var called = false;
21
+ return function() {
22
+ if (called) throw new Error("Callback was already called.");
23
+ called = true;
24
+ fn.apply(root, arguments);
25
+ }
26
+ }
27
+
28
+ //// cross-browser compatiblity functions ////
29
+
30
+ var _each = function (arr, iterator) {
31
+ if (arr.forEach) {
32
+ return arr.forEach(iterator);
33
+ }
34
+ for (var i = 0; i < arr.length; i += 1) {
35
+ iterator(arr[i], i, arr);
36
+ }
37
+ };
38
+
39
+ var _map = function (arr, iterator) {
40
+ if (arr.map) {
41
+ return arr.map(iterator);
42
+ }
43
+ var results = [];
44
+ _each(arr, function (x, i, a) {
45
+ results.push(iterator(x, i, a));
46
+ });
47
+ return results;
48
+ };
49
+
50
+ var _reduce = function (arr, iterator, memo) {
51
+ if (arr.reduce) {
52
+ return arr.reduce(iterator, memo);
53
+ }
54
+ _each(arr, function (x, i, a) {
55
+ memo = iterator(memo, x, i, a);
56
+ });
57
+ return memo;
58
+ };
59
+
60
+ var _keys = function (obj) {
61
+ if (Object.keys) {
62
+ return Object.keys(obj);
63
+ }
64
+ var keys = [];
65
+ for (var k in obj) {
66
+ if (obj.hasOwnProperty(k)) {
67
+ keys.push(k);
68
+ }
69
+ }
70
+ return keys;
71
+ };
72
+
73
+ //// exported async module functions ////
74
+
75
+ //// nextTick implementation with browser-compatible fallback ////
76
+ if (typeof process === 'undefined' || !(process.nextTick)) {
77
+ if (typeof setImmediate === 'function') {
78
+ async.nextTick = function (fn) {
79
+ // not a direct alias for IE10 compatibility
80
+ setImmediate(fn);
81
+ };
82
+ async.setImmediate = async.nextTick;
83
+ }
84
+ else {
85
+ async.nextTick = function (fn) {
86
+ setTimeout(fn, 0);
87
+ };
88
+ async.setImmediate = async.nextTick;
89
+ }
90
+ }
91
+ else {
92
+ async.nextTick = process.nextTick;
93
+ if (typeof setImmediate !== 'undefined') {
94
+ async.setImmediate = function (fn) {
95
+ // not a direct alias for IE10 compatibility
96
+ setImmediate(fn);
97
+ };
98
+ }
99
+ else {
100
+ async.setImmediate = async.nextTick;
101
+ }
102
+ }
103
+
104
+ async.each = function (arr, iterator, callback) {
105
+ callback = callback || function () {};
106
+ if (!arr.length) {
107
+ return callback();
108
+ }
109
+ var completed = 0;
110
+ _each(arr, function (x) {
111
+ iterator(x, only_once(function (err) {
112
+ if (err) {
113
+ callback(err);
114
+ callback = function () {};
115
+ }
116
+ else {
117
+ completed += 1;
118
+ if (completed >= arr.length) {
119
+ callback(null);
120
+ }
121
+ }
122
+ }));
123
+ });
124
+ };
125
+ async.forEach = async.each;
126
+
127
+ async.eachSeries = function (arr, iterator, callback) {
128
+ callback = callback || function () {};
129
+ if (!arr.length) {
130
+ return callback();
131
+ }
132
+ var completed = 0;
133
+ var iterate = function () {
134
+ iterator(arr[completed], function (err) {
135
+ if (err) {
136
+ callback(err);
137
+ callback = function () {};
138
+ }
139
+ else {
140
+ completed += 1;
141
+ if (completed >= arr.length) {
142
+ callback(null);
143
+ }
144
+ else {
145
+ iterate();
146
+ }
147
+ }
148
+ });
149
+ };
150
+ iterate();
151
+ };
152
+ async.forEachSeries = async.eachSeries;
153
+
154
+ async.eachLimit = function (arr, limit, iterator, callback) {
155
+ var fn = _eachLimit(limit);
156
+ fn.apply(null, [arr, iterator, callback]);
157
+ };
158
+ async.forEachLimit = async.eachLimit;
159
+
160
+ var _eachLimit = function (limit) {
161
+
162
+ return function (arr, iterator, callback) {
163
+ callback = callback || function () {};
164
+ if (!arr.length || limit <= 0) {
165
+ return callback();
166
+ }
167
+ var completed = 0;
168
+ var started = 0;
169
+ var running = 0;
170
+
171
+ (function replenish () {
172
+ if (completed >= arr.length) {
173
+ return callback();
174
+ }
175
+
176
+ while (running < limit && started < arr.length) {
177
+ started += 1;
178
+ running += 1;
179
+ iterator(arr[started - 1], function (err) {
180
+ if (err) {
181
+ callback(err);
182
+ callback = function () {};
183
+ }
184
+ else {
185
+ completed += 1;
186
+ running -= 1;
187
+ if (completed >= arr.length) {
188
+ callback();
189
+ }
190
+ else {
191
+ replenish();
192
+ }
193
+ }
194
+ });
195
+ }
196
+ })();
197
+ };
198
+ };
199
+
200
+
201
+ var doParallel = function (fn) {
202
+ return function () {
203
+ var args = Array.prototype.slice.call(arguments);
204
+ return fn.apply(null, [async.each].concat(args));
205
+ };
206
+ };
207
+ var doParallelLimit = function(limit, fn) {
208
+ return function () {
209
+ var args = Array.prototype.slice.call(arguments);
210
+ return fn.apply(null, [_eachLimit(limit)].concat(args));
211
+ };
212
+ };
213
+ var doSeries = function (fn) {
214
+ return function () {
215
+ var args = Array.prototype.slice.call(arguments);
216
+ return fn.apply(null, [async.eachSeries].concat(args));
217
+ };
218
+ };
219
+
220
+
221
+ var _asyncMap = function (eachfn, arr, iterator, callback) {
222
+ var results = [];
223
+ arr = _map(arr, function (x, i) {
224
+ return {index: i, value: x};
225
+ });
226
+ eachfn(arr, function (x, callback) {
227
+ iterator(x.value, function (err, v) {
228
+ results[x.index] = v;
229
+ callback(err);
230
+ });
231
+ }, function (err) {
232
+ callback(err, results);
233
+ });
234
+ };
235
+ async.map = doParallel(_asyncMap);
236
+ async.mapSeries = doSeries(_asyncMap);
237
+ async.mapLimit = function (arr, limit, iterator, callback) {
238
+ return _mapLimit(limit)(arr, iterator, callback);
239
+ };
240
+
241
+ var _mapLimit = function(limit) {
242
+ return doParallelLimit(limit, _asyncMap);
243
+ };
244
+
245
+ // reduce only has a series version, as doing reduce in parallel won't
246
+ // work in many situations.
247
+ async.reduce = function (arr, memo, iterator, callback) {
248
+ async.eachSeries(arr, function (x, callback) {
249
+ iterator(memo, x, function (err, v) {
250
+ memo = v;
251
+ callback(err);
252
+ });
253
+ }, function (err) {
254
+ callback(err, memo);
255
+ });
256
+ };
257
+ // inject alias
258
+ async.inject = async.reduce;
259
+ // foldl alias
260
+ async.foldl = async.reduce;
261
+
262
+ async.reduceRight = function (arr, memo, iterator, callback) {
263
+ var reversed = _map(arr, function (x) {
264
+ return x;
265
+ }).reverse();
266
+ async.reduce(reversed, memo, iterator, callback);
267
+ };
268
+ // foldr alias
269
+ async.foldr = async.reduceRight;
270
+
271
+ var _filter = function (eachfn, arr, iterator, callback) {
272
+ var results = [];
273
+ arr = _map(arr, function (x, i) {
274
+ return {index: i, value: x};
275
+ });
276
+ eachfn(arr, function (x, callback) {
277
+ iterator(x.value, function (v) {
278
+ if (v) {
279
+ results.push(x);
280
+ }
281
+ callback();
282
+ });
283
+ }, function (err) {
284
+ callback(_map(results.sort(function (a, b) {
285
+ return a.index - b.index;
286
+ }), function (x) {
287
+ return x.value;
288
+ }));
289
+ });
290
+ };
291
+ async.filter = doParallel(_filter);
292
+ async.filterSeries = doSeries(_filter);
293
+ // select alias
294
+ async.select = async.filter;
295
+ async.selectSeries = async.filterSeries;
296
+
297
+ var _reject = function (eachfn, arr, iterator, callback) {
298
+ var results = [];
299
+ arr = _map(arr, function (x, i) {
300
+ return {index: i, value: x};
301
+ });
302
+ eachfn(arr, function (x, callback) {
303
+ iterator(x.value, function (v) {
304
+ if (!v) {
305
+ results.push(x);
306
+ }
307
+ callback();
308
+ });
309
+ }, function (err) {
310
+ callback(_map(results.sort(function (a, b) {
311
+ return a.index - b.index;
312
+ }), function (x) {
313
+ return x.value;
314
+ }));
315
+ });
316
+ };
317
+ async.reject = doParallel(_reject);
318
+ async.rejectSeries = doSeries(_reject);
319
+
320
+ var _detect = function (eachfn, arr, iterator, main_callback) {
321
+ eachfn(arr, function (x, callback) {
322
+ iterator(x, function (result) {
323
+ if (result) {
324
+ main_callback(x);
325
+ main_callback = function () {};
326
+ }
327
+ else {
328
+ callback();
329
+ }
330
+ });
331
+ }, function (err) {
332
+ main_callback();
333
+ });
334
+ };
335
+ async.detect = doParallel(_detect);
336
+ async.detectSeries = doSeries(_detect);
337
+
338
+ async.some = function (arr, iterator, main_callback) {
339
+ async.each(arr, function (x, callback) {
340
+ iterator(x, function (v) {
341
+ if (v) {
342
+ main_callback(true);
343
+ main_callback = function () {};
344
+ }
345
+ callback();
346
+ });
347
+ }, function (err) {
348
+ main_callback(false);
349
+ });
350
+ };
351
+ // any alias
352
+ async.any = async.some;
353
+
354
+ async.every = function (arr, iterator, main_callback) {
355
+ async.each(arr, function (x, callback) {
356
+ iterator(x, function (v) {
357
+ if (!v) {
358
+ main_callback(false);
359
+ main_callback = function () {};
360
+ }
361
+ callback();
362
+ });
363
+ }, function (err) {
364
+ main_callback(true);
365
+ });
366
+ };
367
+ // all alias
368
+ async.all = async.every;
369
+
370
+ async.sortBy = function (arr, iterator, callback) {
371
+ async.map(arr, function (x, callback) {
372
+ iterator(x, function (err, criteria) {
373
+ if (err) {
374
+ callback(err);
375
+ }
376
+ else {
377
+ callback(null, {value: x, criteria: criteria});
378
+ }
379
+ });
380
+ }, function (err, results) {
381
+ if (err) {
382
+ return callback(err);
383
+ }
384
+ else {
385
+ var fn = function (left, right) {
386
+ var a = left.criteria, b = right.criteria;
387
+ return a < b ? -1 : a > b ? 1 : 0;
388
+ };
389
+ callback(null, _map(results.sort(fn), function (x) {
390
+ return x.value;
391
+ }));
392
+ }
393
+ });
394
+ };
395
+
396
+ async.auto = function (tasks, callback) {
397
+ callback = callback || function () {};
398
+ var keys = _keys(tasks);
399
+ if (!keys.length) {
400
+ return callback(null);
401
+ }
402
+
403
+ var results = {};
404
+
405
+ var listeners = [];
406
+ var addListener = function (fn) {
407
+ listeners.unshift(fn);
408
+ };
409
+ var removeListener = function (fn) {
410
+ for (var i = 0; i < listeners.length; i += 1) {
411
+ if (listeners[i] === fn) {
412
+ listeners.splice(i, 1);
413
+ return;
414
+ }
415
+ }
416
+ };
417
+ var taskComplete = function () {
418
+ _each(listeners.slice(0), function (fn) {
419
+ fn();
420
+ });
421
+ };
422
+
423
+ addListener(function () {
424
+ if (_keys(results).length === keys.length) {
425
+ callback(null, results);
426
+ callback = function () {};
427
+ }
428
+ });
429
+
430
+ _each(keys, function (k) {
431
+ var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
432
+ var taskCallback = function (err) {
433
+ var args = Array.prototype.slice.call(arguments, 1);
434
+ if (args.length <= 1) {
435
+ args = args[0];
436
+ }
437
+ if (err) {
438
+ var safeResults = {};
439
+ _each(_keys(results), function(rkey) {
440
+ safeResults[rkey] = results[rkey];
441
+ });
442
+ safeResults[k] = args;
443
+ callback(err, safeResults);
444
+ // stop subsequent errors hitting callback multiple times
445
+ callback = function () {};
446
+ }
447
+ else {
448
+ results[k] = args;
449
+ async.setImmediate(taskComplete);
450
+ }
451
+ };
452
+ var requires = task.slice(0, Math.abs(task.length - 1)) || [];
453
+ var ready = function () {
454
+ return _reduce(requires, function (a, x) {
455
+ return (a && results.hasOwnProperty(x));
456
+ }, true) && !results.hasOwnProperty(k);
457
+ };
458
+ if (ready()) {
459
+ task[task.length - 1](taskCallback, results);
460
+ }
461
+ else {
462
+ var listener = function () {
463
+ if (ready()) {
464
+ removeListener(listener);
465
+ task[task.length - 1](taskCallback, results);
466
+ }
467
+ };
468
+ addListener(listener);
469
+ }
470
+ });
471
+ };
472
+
473
+ async.waterfall = function (tasks, callback) {
474
+ callback = callback || function () {};
475
+ if (tasks.constructor !== Array) {
476
+ var err = new Error('First argument to waterfall must be an array of functions');
477
+ return callback(err);
478
+ }
479
+ if (!tasks.length) {
480
+ return callback();
481
+ }
482
+ var wrapIterator = function (iterator) {
483
+ return function (err) {
484
+ if (err) {
485
+ callback.apply(null, arguments);
486
+ callback = function () {};
487
+ }
488
+ else {
489
+ var args = Array.prototype.slice.call(arguments, 1);
490
+ var next = iterator.next();
491
+ if (next) {
492
+ args.push(wrapIterator(next));
493
+ }
494
+ else {
495
+ args.push(callback);
496
+ }
497
+ async.setImmediate(function () {
498
+ iterator.apply(null, args);
499
+ });
500
+ }
501
+ };
502
+ };
503
+ wrapIterator(async.iterator(tasks))();
504
+ };
505
+
506
+ var _parallel = function(eachfn, tasks, callback) {
507
+ callback = callback || function () {};
508
+ if (tasks.constructor === Array) {
509
+ eachfn.map(tasks, function (fn, callback) {
510
+ if (fn) {
511
+ fn(function (err) {
512
+ var args = Array.prototype.slice.call(arguments, 1);
513
+ if (args.length <= 1) {
514
+ args = args[0];
515
+ }
516
+ callback.call(null, err, args);
517
+ });
518
+ }
519
+ }, callback);
520
+ }
521
+ else {
522
+ var results = {};
523
+ eachfn.each(_keys(tasks), function (k, callback) {
524
+ tasks[k](function (err) {
525
+ var args = Array.prototype.slice.call(arguments, 1);
526
+ if (args.length <= 1) {
527
+ args = args[0];
528
+ }
529
+ results[k] = args;
530
+ callback(err);
531
+ });
532
+ }, function (err) {
533
+ callback(err, results);
534
+ });
535
+ }
536
+ };
537
+
538
+ async.parallel = function (tasks, callback) {
539
+ _parallel({ map: async.map, each: async.each }, tasks, callback);
540
+ };
541
+
542
+ async.parallelLimit = function(tasks, limit, callback) {
543
+ _parallel({ map: _mapLimit(limit), each: _eachLimit(limit) }, tasks, callback);
544
+ };
545
+
546
+ async.series = function (tasks, callback) {
547
+ callback = callback || function () {};
548
+ if (tasks.constructor === Array) {
549
+ async.mapSeries(tasks, function (fn, callback) {
550
+ if (fn) {
551
+ fn(function (err) {
552
+ var args = Array.prototype.slice.call(arguments, 1);
553
+ if (args.length <= 1) {
554
+ args = args[0];
555
+ }
556
+ callback.call(null, err, args);
557
+ });
558
+ }
559
+ }, callback);
560
+ }
561
+ else {
562
+ var results = {};
563
+ async.eachSeries(_keys(tasks), function (k, callback) {
564
+ tasks[k](function (err) {
565
+ var args = Array.prototype.slice.call(arguments, 1);
566
+ if (args.length <= 1) {
567
+ args = args[0];
568
+ }
569
+ results[k] = args;
570
+ callback(err);
571
+ });
572
+ }, function (err) {
573
+ callback(err, results);
574
+ });
575
+ }
576
+ };
577
+
578
+ async.iterator = function (tasks) {
579
+ var makeCallback = function (index) {
580
+ var fn = function () {
581
+ if (tasks.length) {
582
+ tasks[index].apply(null, arguments);
583
+ }
584
+ return fn.next();
585
+ };
586
+ fn.next = function () {
587
+ return (index < tasks.length - 1) ? makeCallback(index + 1): null;
588
+ };
589
+ return fn;
590
+ };
591
+ return makeCallback(0);
592
+ };
593
+
594
+ async.apply = function (fn) {
595
+ var args = Array.prototype.slice.call(arguments, 1);
596
+ return function () {
597
+ return fn.apply(
598
+ null, args.concat(Array.prototype.slice.call(arguments))
599
+ );
600
+ };
601
+ };
602
+
603
+ var _concat = function (eachfn, arr, fn, callback) {
604
+ var r = [];
605
+ eachfn(arr, function (x, cb) {
606
+ fn(x, function (err, y) {
607
+ r = r.concat(y || []);
608
+ cb(err);
609
+ });
610
+ }, function (err) {
611
+ callback(err, r);
612
+ });
613
+ };
614
+ async.concat = doParallel(_concat);
615
+ async.concatSeries = doSeries(_concat);
616
+
617
+ async.whilst = function (test, iterator, callback) {
618
+ if (test()) {
619
+ iterator(function (err) {
620
+ if (err) {
621
+ return callback(err);
622
+ }
623
+ async.whilst(test, iterator, callback);
624
+ });
625
+ }
626
+ else {
627
+ callback();
628
+ }
629
+ };
630
+
631
+ async.doWhilst = function (iterator, test, callback) {
632
+ iterator(function (err) {
633
+ if (err) {
634
+ return callback(err);
635
+ }
636
+ if (test()) {
637
+ async.doWhilst(iterator, test, callback);
638
+ }
639
+ else {
640
+ callback();
641
+ }
642
+ });
643
+ };
644
+
645
+ async.until = function (test, iterator, callback) {
646
+ if (!test()) {
647
+ iterator(function (err) {
648
+ if (err) {
649
+ return callback(err);
650
+ }
651
+ async.until(test, iterator, callback);
652
+ });
653
+ }
654
+ else {
655
+ callback();
656
+ }
657
+ };
658
+
659
+ async.doUntil = function (iterator, test, callback) {
660
+ iterator(function (err) {
661
+ if (err) {
662
+ return callback(err);
663
+ }
664
+ if (!test()) {
665
+ async.doUntil(iterator, test, callback);
666
+ }
667
+ else {
668
+ callback();
669
+ }
670
+ });
671
+ };
672
+
673
+ async.queue = function (worker, concurrency) {
674
+ if (concurrency === undefined) {
675
+ concurrency = 1;
676
+ }
677
+ function _insert(q, data, pos, callback) {
678
+ if(data.constructor !== Array) {
679
+ data = [data];
680
+ }
681
+ _each(data, function(task) {
682
+ var item = {
683
+ data: task,
684
+ callback: typeof callback === 'function' ? callback : null
685
+ };
686
+
687
+ if (pos) {
688
+ q.tasks.unshift(item);
689
+ } else {
690
+ q.tasks.push(item);
691
+ }
692
+
693
+ if (q.saturated && q.tasks.length === concurrency) {
694
+ q.saturated();
695
+ }
696
+ async.setImmediate(q.process);
697
+ });
698
+ }
699
+
700
+ var workers = 0;
701
+ var q = {
702
+ tasks: [],
703
+ concurrency: concurrency,
704
+ saturated: null,
705
+ empty: null,
706
+ drain: null,
707
+ push: function (data, callback) {
708
+ _insert(q, data, false, callback);
709
+ },
710
+ unshift: function (data, callback) {
711
+ _insert(q, data, true, callback);
712
+ },
713
+ process: function () {
714
+ if (workers < q.concurrency && q.tasks.length) {
715
+ var task = q.tasks.shift();
716
+ if (q.empty && q.tasks.length === 0) {
717
+ q.empty();
718
+ }
719
+ workers += 1;
720
+ var next = function () {
721
+ workers -= 1;
722
+ if (task.callback) {
723
+ task.callback.apply(task, arguments);
724
+ }
725
+ if (q.drain && q.tasks.length + workers === 0) {
726
+ q.drain();
727
+ }
728
+ q.process();
729
+ };
730
+ var cb = only_once(next);
731
+ worker(task.data, cb);
732
+ }
733
+ },
734
+ length: function () {
735
+ return q.tasks.length;
736
+ },
737
+ running: function () {
738
+ return workers;
739
+ }
740
+ };
741
+ return q;
742
+ };
743
+
744
+ async.cargo = function (worker, payload) {
745
+ var working = false,
746
+ tasks = [];
747
+
748
+ var cargo = {
749
+ tasks: tasks,
750
+ payload: payload,
751
+ saturated: null,
752
+ empty: null,
753
+ drain: null,
754
+ push: function (data, callback) {
755
+ if(data.constructor !== Array) {
756
+ data = [data];
757
+ }
758
+ _each(data, function(task) {
759
+ tasks.push({
760
+ data: task,
761
+ callback: typeof callback === 'function' ? callback : null
762
+ });
763
+ if (cargo.saturated && tasks.length === payload) {
764
+ cargo.saturated();
765
+ }
766
+ });
767
+ async.setImmediate(cargo.process);
768
+ },
769
+ process: function process() {
770
+ if (working) return;
771
+ if (tasks.length === 0) {
772
+ if(cargo.drain) cargo.drain();
773
+ return;
774
+ }
775
+
776
+ var ts = typeof payload === 'number'
777
+ ? tasks.splice(0, payload)
778
+ : tasks.splice(0);
779
+
780
+ var ds = _map(ts, function (task) {
781
+ return task.data;
782
+ });
783
+
784
+ if(cargo.empty) cargo.empty();
785
+ working = true;
786
+ worker(ds, function () {
787
+ working = false;
788
+
789
+ var args = arguments;
790
+ _each(ts, function (data) {
791
+ if (data.callback) {
792
+ data.callback.apply(null, args);
793
+ }
794
+ });
795
+
796
+ process();
797
+ });
798
+ },
799
+ length: function () {
800
+ return tasks.length;
801
+ },
802
+ running: function () {
803
+ return working;
804
+ }
805
+ };
806
+ return cargo;
807
+ };
808
+
809
+ var _console_fn = function (name) {
810
+ return function (fn) {
811
+ var args = Array.prototype.slice.call(arguments, 1);
812
+ fn.apply(null, args.concat([function (err) {
813
+ var args = Array.prototype.slice.call(arguments, 1);
814
+ if (typeof console !== 'undefined') {
815
+ if (err) {
816
+ if (console.error) {
817
+ console.error(err);
818
+ }
819
+ }
820
+ else if (console[name]) {
821
+ _each(args, function (x) {
822
+ console[name](x);
823
+ });
824
+ }
825
+ }
826
+ }]));
827
+ };
828
+ };
829
+ async.log = _console_fn('log');
830
+ async.dir = _console_fn('dir');
831
+ /*async.info = _console_fn('info');
832
+ async.warn = _console_fn('warn');
833
+ async.error = _console_fn('error');*/
834
+
835
+ async.memoize = function (fn, hasher) {
836
+ var memo = {};
837
+ var queues = {};
838
+ hasher = hasher || function (x) {
839
+ return x;
840
+ };
841
+ var memoized = function () {
842
+ var args = Array.prototype.slice.call(arguments);
843
+ var callback = args.pop();
844
+ var key = hasher.apply(null, args);
845
+ if (key in memo) {
846
+ callback.apply(null, memo[key]);
847
+ }
848
+ else if (key in queues) {
849
+ queues[key].push(callback);
850
+ }
851
+ else {
852
+ queues[key] = [callback];
853
+ fn.apply(null, args.concat([function () {
854
+ memo[key] = arguments;
855
+ var q = queues[key];
856
+ delete queues[key];
857
+ for (var i = 0, l = q.length; i < l; i++) {
858
+ q[i].apply(null, arguments);
859
+ }
860
+ }]));
861
+ }
862
+ };
863
+ memoized.memo = memo;
864
+ memoized.unmemoized = fn;
865
+ return memoized;
866
+ };
867
+
868
+ async.unmemoize = function (fn) {
869
+ return function () {
870
+ return (fn.unmemoized || fn).apply(null, arguments);
871
+ };
872
+ };
873
+
874
+ async.times = function (count, iterator, callback) {
875
+ var counter = [];
876
+ for (var i = 0; i < count; i++) {
877
+ counter.push(i);
878
+ }
879
+ return async.map(counter, iterator, callback);
880
+ };
881
+
882
+ async.timesSeries = function (count, iterator, callback) {
883
+ var counter = [];
884
+ for (var i = 0; i < count; i++) {
885
+ counter.push(i);
886
+ }
887
+ return async.mapSeries(counter, iterator, callback);
888
+ };
889
+
890
+ async.compose = function (/* functions... */) {
891
+ var fns = Array.prototype.reverse.call(arguments);
892
+ return function () {
893
+ var that = this;
894
+ var args = Array.prototype.slice.call(arguments);
895
+ var callback = args.pop();
896
+ async.reduce(fns, args, function (newargs, fn, cb) {
897
+ fn.apply(that, newargs.concat([function () {
898
+ var err = arguments[0];
899
+ var nextargs = Array.prototype.slice.call(arguments, 1);
900
+ cb(err, nextargs);
901
+ }]))
902
+ },
903
+ function (err, results) {
904
+ callback.apply(that, [err].concat(results));
905
+ });
906
+ };
907
+ };
908
+
909
+ var _applyEach = function (eachfn, fns /*args...*/) {
910
+ var go = function () {
911
+ var that = this;
912
+ var args = Array.prototype.slice.call(arguments);
913
+ var callback = args.pop();
914
+ return eachfn(fns, function (fn, cb) {
915
+ fn.apply(that, args.concat([cb]));
916
+ },
917
+ callback);
918
+ };
919
+ if (arguments.length > 2) {
920
+ var args = Array.prototype.slice.call(arguments, 2);
921
+ return go.apply(this, args);
922
+ }
923
+ else {
924
+ return go;
925
+ }
926
+ };
927
+ async.applyEach = doParallel(_applyEach);
928
+ async.applyEachSeries = doSeries(_applyEach);
929
+
930
+ async.forever = function (fn, callback) {
931
+ function next(err) {
932
+ if (err) {
933
+ if (callback) {
934
+ return callback(err);
935
+ }
936
+ throw err;
937
+ }
938
+ fn(next);
939
+ }
940
+ next();
941
+ };
942
+
943
+ // AMD / RequireJS
944
+ if (typeof define !== 'undefined' && define.amd) {
945
+ define([], function () {
946
+ return async;
947
+ });
948
+ }
949
+ // Node.js
950
+ else if (typeof module !== 'undefined' && module.exports) {
951
+ module.exports = async;
952
+ }
953
+ // included directly via <script> tag
954
+ else {
955
+ root.async = async;
956
+ }
957
+
958
+ }());