FilesExpand file tree

 master

/

autoInject.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

170 lines (146 loc) · 6.33 KB

 master

/

autoInject.js

Copy path

Top

File metadata and controls

• Code
• Blame

170 lines (146 loc) · 6.33 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

'use strict';

Object.defineProperty(exports, "__esModule", {

value: true

});

exports.default = autoInject;

var _auto = require('./auto');

var _auto2 = _interopRequireDefault(_auto);

var _baseForOwn = require('lodash/_baseForOwn');

var _baseForOwn2 = _interopRequireDefault(_baseForOwn);

var _arrayMap = require('lodash/_arrayMap');

var _arrayMap2 = _interopRequireDefault(_arrayMap);

var _isArray = require('lodash/isArray');

var _isArray2 = _interopRequireDefault(_isArray);

var _trim = require('lodash/trim');

var _trim2 = _interopRequireDefault(_trim);

var _wrapAsync = require('./internal/wrapAsync');

var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;

var FN_ARG_SPLIT = /,/;

var FN_ARG = /(=.+)?(\s*)$/;

var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;

function parseParams(func) {

func = func.toString().replace(STRIP_COMMENTS, '');

func = func.match(FN_ARGS)[2].replace(' ', '');

func = func ? func.split(FN_ARG_SPLIT) : [];

func = func.map(function (arg) {

return (0, _trim2.default)(arg.replace(FN_ARG, ''));

});

return func;

}

/**

* A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent

* tasks are specified as parameters to the function, after the usual callback

* parameter, with the parameter names matching the names of the tasks it

* depends on. This can provide even more readable task graphs which can be

* easier to maintain.

*

* If a final callback is specified, the task results are similarly injected,

* specified as named parameters after the initial error parameter.

*

* The autoInject function is purely syntactic sugar and its semantics are

* otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.

*

* @name autoInject

* @static

* @memberOf module:ControlFlow

* @method

* @see [async.auto]{@link module:ControlFlow.auto}

* @category Control Flow

* @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of

* the form 'func([dependencies...], callback). The object's key of a property

* serves as the name of the task defined by that property, i.e. can be used

* when specifying requirements for other tasks.

* * The `callback` parameter is a `callback(err, result)` which must be called

* when finished, passing an `error` (which can be `null`) and the result of

* the function's execution. The remaining parameters name other tasks on

* which the task is dependent, and the results from those tasks are the

* arguments of those parameters.

* @param {Function} [callback] - An optional callback which is called when all

* the tasks have been completed. It receives the `err` argument if any `tasks`

* pass an error to their callback, and a `results` object with any completed

* task results, similar to `auto`.

* @example

*

* // The example from `auto` can be rewritten as follows:

* async.autoInject({

* get_data: function(callback) {

* // async code to get some data

* callback(null, 'data', 'converted to array');

* },

* make_folder: function(callback) {

* // async code to create a directory to store a file in

* // this is run at the same time as getting the data

* callback(null, 'folder');

* },

* write_file: function(get_data, make_folder, callback) {

* // once there is some data and the directory exists,

* // write the data to a file in the directory

* callback(null, 'filename');

* },

* email_link: function(write_file, callback) {

* // once the file is written let's email a link to it...

* // write_file contains the filename returned by write_file.

* callback(null, {'file':write_file, 'email':'user@example.com'});

* }

* }, function(err, results) {

* console.log('err = ', err);

* console.log('email_link = ', results.email_link);

* });

*

* // If you are using a JS minifier that mangles parameter names, `autoInject`

* // will not work with plain functions, since the parameter names will be

* // collapsed to a single letter identifier. To work around this, you can

* // explicitly specify the names of the parameters your task function needs

* // in an array, similar to Angular.js dependency injection.

*

* // This still has an advantage over plain `auto`, since the results a task

* // depends on are still spread into arguments.

* async.autoInject({

* //...

* write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {

* callback(null, 'filename');

* }],

* email_link: ['write_file', function(write_file, callback) {

* callback(null, {'file':write_file, 'email':'user@example.com'});

* }]

* //...

* }, function(err, results) {

* console.log('err = ', err);

* console.log('email_link = ', results.email_link);

* });

*/

function autoInject(tasks, callback) {

var newTasks = {};

(0, _baseForOwn2.default)(tasks, function (taskFn, key) {

var params;

var fnIsAsync = (0, _wrapAsync.isAsync)(taskFn);

var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;

if ((0, _isArray2.default)(taskFn)) {

params = taskFn.slice(0, -1);

taskFn = taskFn[taskFn.length - 1];

newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);

} else if (hasNoDeps) {

// no dependencies, use the function as-is

newTasks[key] = taskFn;

} else {

params = parseParams(taskFn);

if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {

throw new Error("autoInject task functions require explicit parameters.");

}

// remove callback param

if (!fnIsAsync) params.pop();

newTasks[key] = params.concat(newTask);

}

function newTask(results, taskCb) {

var newArgs = (0, _arrayMap2.default)(params, function (name) {

return results[name];

});

newArgs.push(taskCb);

(0, _wrapAsync2.default)(taskFn).apply(null, newArgs);

}

});

(0, _auto2.default)(newTasks, callback);

}

module.exports = exports['default'];