source: trip-planner-front/node_modules/async/autoInject.js@ 188ee53

Last change on this file since 188ee53 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 6.3 KB
Line 
1'use strict';
2
3Object.defineProperty(exports, "__esModule", {
4 value: true
5});
6exports.default = autoInject;
7
8var _auto = require('./auto');
9
10var _auto2 = _interopRequireDefault(_auto);
11
12var _baseForOwn = require('lodash/_baseForOwn');
13
14var _baseForOwn2 = _interopRequireDefault(_baseForOwn);
15
16var _arrayMap = require('lodash/_arrayMap');
17
18var _arrayMap2 = _interopRequireDefault(_arrayMap);
19
20var _isArray = require('lodash/isArray');
21
22var _isArray2 = _interopRequireDefault(_isArray);
23
24var _trim = require('lodash/trim');
25
26var _trim2 = _interopRequireDefault(_trim);
27
28var _wrapAsync = require('./internal/wrapAsync');
29
30var _wrapAsync2 = _interopRequireDefault(_wrapAsync);
31
32function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
33
34var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
35var FN_ARG_SPLIT = /,/;
36var FN_ARG = /(=.+)?(\s*)$/;
37var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
38
39function parseParams(func) {
40 func = func.toString().replace(STRIP_COMMENTS, '');
41 func = func.match(FN_ARGS)[2].replace(' ', '');
42 func = func ? func.split(FN_ARG_SPLIT) : [];
43 func = func.map(function (arg) {
44 return (0, _trim2.default)(arg.replace(FN_ARG, ''));
45 });
46 return func;
47}
48
49/**
50 * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
51 * tasks are specified as parameters to the function, after the usual callback
52 * parameter, with the parameter names matching the names of the tasks it
53 * depends on. This can provide even more readable task graphs which can be
54 * easier to maintain.
55 *
56 * If a final callback is specified, the task results are similarly injected,
57 * specified as named parameters after the initial error parameter.
58 *
59 * The autoInject function is purely syntactic sugar and its semantics are
60 * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.
61 *
62 * @name autoInject
63 * @static
64 * @memberOf module:ControlFlow
65 * @method
66 * @see [async.auto]{@link module:ControlFlow.auto}
67 * @category Control Flow
68 * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of
69 * the form 'func([dependencies...], callback). The object's key of a property
70 * serves as the name of the task defined by that property, i.e. can be used
71 * when specifying requirements for other tasks.
72 * * The `callback` parameter is a `callback(err, result)` which must be called
73 * when finished, passing an `error` (which can be `null`) and the result of
74 * the function's execution. The remaining parameters name other tasks on
75 * which the task is dependent, and the results from those tasks are the
76 * arguments of those parameters.
77 * @param {Function} [callback] - An optional callback which is called when all
78 * the tasks have been completed. It receives the `err` argument if any `tasks`
79 * pass an error to their callback, and a `results` object with any completed
80 * task results, similar to `auto`.
81 * @example
82 *
83 * // The example from `auto` can be rewritten as follows:
84 * async.autoInject({
85 * get_data: function(callback) {
86 * // async code to get some data
87 * callback(null, 'data', 'converted to array');
88 * },
89 * make_folder: function(callback) {
90 * // async code to create a directory to store a file in
91 * // this is run at the same time as getting the data
92 * callback(null, 'folder');
93 * },
94 * write_file: function(get_data, make_folder, callback) {
95 * // once there is some data and the directory exists,
96 * // write the data to a file in the directory
97 * callback(null, 'filename');
98 * },
99 * email_link: function(write_file, callback) {
100 * // once the file is written let's email a link to it...
101 * // write_file contains the filename returned by write_file.
102 * callback(null, {'file':write_file, 'email':'user@example.com'});
103 * }
104 * }, function(err, results) {
105 * console.log('err = ', err);
106 * console.log('email_link = ', results.email_link);
107 * });
108 *
109 * // If you are using a JS minifier that mangles parameter names, `autoInject`
110 * // will not work with plain functions, since the parameter names will be
111 * // collapsed to a single letter identifier. To work around this, you can
112 * // explicitly specify the names of the parameters your task function needs
113 * // in an array, similar to Angular.js dependency injection.
114 *
115 * // This still has an advantage over plain `auto`, since the results a task
116 * // depends on are still spread into arguments.
117 * async.autoInject({
118 * //...
119 * write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
120 * callback(null, 'filename');
121 * }],
122 * email_link: ['write_file', function(write_file, callback) {
123 * callback(null, {'file':write_file, 'email':'user@example.com'});
124 * }]
125 * //...
126 * }, function(err, results) {
127 * console.log('err = ', err);
128 * console.log('email_link = ', results.email_link);
129 * });
130 */
131function autoInject(tasks, callback) {
132 var newTasks = {};
133
134 (0, _baseForOwn2.default)(tasks, function (taskFn, key) {
135 var params;
136 var fnIsAsync = (0, _wrapAsync.isAsync)(taskFn);
137 var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;
138
139 if ((0, _isArray2.default)(taskFn)) {
140 params = taskFn.slice(0, -1);
141 taskFn = taskFn[taskFn.length - 1];
142
143 newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
144 } else if (hasNoDeps) {
145 // no dependencies, use the function as-is
146 newTasks[key] = taskFn;
147 } else {
148 params = parseParams(taskFn);
149 if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
150 throw new Error("autoInject task functions require explicit parameters.");
151 }
152
153 // remove callback param
154 if (!fnIsAsync) params.pop();
155
156 newTasks[key] = params.concat(newTask);
157 }
158
159 function newTask(results, taskCb) {
160 var newArgs = (0, _arrayMap2.default)(params, function (name) {
161 return results[name];
162 });
163 newArgs.push(taskCb);
164 (0, _wrapAsync2.default)(taskFn).apply(null, newArgs);
165 }
166 });
167
168 (0, _auto2.default)(newTasks, callback);
169}
170module.exports = exports['default'];
Note: See TracBrowser for help on using the repository browser.