1 | ;
|
2 | var task_resolve_1 = require("./task.resolve");
|
3 | var _ = require("../lodash.custom");
|
4 | var Rx = require("rx");
|
5 | var Observable = Rx.Observable;
|
6 | var adaptors = require("./adaptors");
|
7 | var Immutable = require("immutable");
|
8 | var task_sequence_factories_1 = require("./task.sequence.factories");
|
9 | var task_runner_1 = require("./task.runner");
|
10 | var task_utils_1 = require("./task.utils");
|
11 | function createFlattenedSequence(tasks, trigger) {
|
12 | return flatten(tasks, []);
|
13 | function flatten(items, initial, options, viaName) {
|
14 | return items.reduce(function (all, task) {
|
15 | /**
|
16 | * If the current task has child tasks, we build a tree of
|
17 | * nested observables for it (a task with children cannot itself
|
18 | * be a task that should be run)
|
19 | */
|
20 | if (task.type === task_resolve_1.TaskTypes.TaskGroup || task.type === task_resolve_1.TaskTypes.ParentGroup) {
|
21 | /**
|
22 | * If we're looking at a group of tasks that was run
|
23 | * with sub-tasks, we need to resolve differently to
|
24 | * allow things such as parallel running to work as expected
|
25 | */
|
26 | if (task.subTasks.length && task.tasks.length) {
|
27 | /**
|
28 | * Build the list of tasks/groups
|
29 | * @type {Array}
|
30 | */
|
31 | var output = resolveGroupOfTasks(task, trigger.input);
|
32 | /**
|
33 | * Wrap as parallel group if this task has a runMode of 'parallel'
|
34 | */
|
35 | if (task.runMode === task_resolve_1.TaskRunModes.parallel) {
|
36 | return all.concat(task_sequence_factories_1.createSequenceParallelGroup({
|
37 | taskName: task.taskName,
|
38 | items: output,
|
39 | skipped: task.skipped
|
40 | }));
|
41 | }
|
42 | /**
|
43 | * Wrap as a series group if this task has a runMode of 'series'
|
44 | */
|
45 | if (task.runMode === task_resolve_1.TaskRunModes.series) {
|
46 | return all.concat(task_sequence_factories_1.createSequenceSeriesGroup({
|
47 | taskName: task.taskName,
|
48 | items: output,
|
49 | skipped: task.skipped
|
50 | }));
|
51 | }
|
52 | }
|
53 | /**
|
54 | * If the current task was marked as `parallel`, all immediate children
|
55 | * of (this task) will be run in `parallel`
|
56 | */
|
57 | if (task.runMode === task_resolve_1.TaskRunModes.parallel) {
|
58 | return all.concat(resolveGroup(task, task_sequence_factories_1.createSequenceParallelGroup));
|
59 | }
|
60 | /**
|
61 | * If the current task was marked as `series`, all immediate child tasks
|
62 | * will be queued and run in series - each waiting until the previous
|
63 | * one has completed
|
64 | */
|
65 | if (task.runMode === task_resolve_1.TaskRunModes.series) {
|
66 | return all.concat(resolveGroup(task, task_sequence_factories_1.createSequenceSeriesGroup));
|
67 | }
|
68 | }
|
69 | /**
|
70 | * At this point, we must be dealing with a task that should be run,
|
71 | * so we first check if it's an adaptor @ task first
|
72 | */
|
73 | if (task.type === task_resolve_1.TaskTypes.Adaptor) {
|
74 | return all.concat(getSequenceItemWithOptions(task, trigger, adaptors[task.adaptor].create(task, trigger), {}));
|
75 | }
|
76 | /**
|
77 | * Finally, if the does not have children tasks & is not an
|
78 | * adaptor task it must have at least 1 associated module
|
79 | * (or an inline function) so we can begin working with it
|
80 | * by first resolving the top-level options object for it.
|
81 | */
|
82 | var localOptions = _.assign({}, loadTopLevelOptions(task, trigger), options);
|
83 | /**
|
84 | * Decide where the callable function is coming from
|
85 | * (inline function, external task etc)
|
86 | * @type {CBFunction}
|
87 | */
|
88 | var callable = (function () {
|
89 | if (task.type === task_resolve_1.TaskTypes.InlineFunction) {
|
90 | return task.inlineFunctions[0];
|
91 | }
|
92 | return require(task.externalTasks[0].resolved);
|
93 | })();
|
94 | /**
|
95 | * Take the callable and create items with it + options
|
96 | */
|
97 | return all.concat(resolveFromFunction(task, callable, trigger, localOptions, viaName));
|
98 | }, initial);
|
99 | }
|
100 | /**
|
101 | * Resolve a group of tasks
|
102 | * @param task
|
103 | * @param groupCreatorFn
|
104 | * @param continueFn
|
105 | * @returns {any}
|
106 | */
|
107 | function resolveGroup(task, groupCreatorFn) {
|
108 | /**
|
109 | * If the group contains no subtasks
|
110 | */
|
111 | if (!task.subTasks.length) {
|
112 | /**
|
113 | * If a group has _default options,
|
114 | * but here no 'subTasks' were given, use the
|
115 | * default options always
|
116 | */
|
117 | var parentOptions = (function () {
|
118 | if (task.options._default !== undefined) {
|
119 | return _.merge({}, task.options._default, task.query, task.flags);
|
120 | }
|
121 | return task.options;
|
122 | })();
|
123 | /**
|
124 | * Here the group had no direct 'sub tasks', so just return the item
|
125 | */
|
126 | return [groupCreatorFn({
|
127 | taskName: task.taskName,
|
128 | items: flatten(task.tasks, [], parentOptions),
|
129 | skipped: task.skipped
|
130 | })];
|
131 | }
|
132 | /**
|
133 | * Use either subtasks directly, or if '*' was given, use
|
134 | * each key in the object to create a task
|
135 | */
|
136 | var lookupKeys = getLookupKeys(task.subTasks, task.options);
|
137 | /**
|
138 | * Now for each sub-task create a separate task item
|
139 | */
|
140 | return lookupKeys.map(function (subTaskName) {
|
141 | /**
|
142 | * When things like options, flags or query strings
|
143 | * were present on this task-group - pass them into the upcoming task instead
|
144 | * Order of presedence
|
145 | * flags -> query -> options -> shared
|
146 | */
|
147 | var taskOptions = _.merge({}, task.options._default, _.get(task.options, subTaskName, {}), task.query, task.flags);
|
148 | return groupCreatorFn({
|
149 | taskName: task.taskName,
|
150 | items: flatten(task.tasks, [], taskOptions, task.taskName + ":" + subTaskName),
|
151 | skipped: task.skipped,
|
152 | subTaskName: subTaskName
|
153 | });
|
154 | });
|
155 | }
|
156 | function resolveGroupOfTasks(task, input) {
|
157 | if (task.type === task_resolve_1.TaskTypes.ParentGroup) {
|
158 | var opts = _.merge({}, task.options._default, task.query, task.flags);
|
159 | return flatten(task.tasks, [], opts, task.taskName);
|
160 | }
|
161 | var lookupKeys = getLookupKeys(task.subTasks, task.options);
|
162 | return lookupKeys.reduce(function (acc, subTaskName) {
|
163 | var opts = _.merge({}, task.options._default, _.get(task.options, subTaskName, {}), _.get(input.options, [task.baseTaskName, subTaskName], {}), task.query, task.flags);
|
164 | return acc.concat(flatten(task.tasks, [], opts, task.taskName + ":" + subTaskName));
|
165 | }, []);
|
166 | }
|
167 | }
|
168 | exports.createFlattenedSequence = createFlattenedSequence;
|
169 | function resolveFromFunction(task, callable, trigger, localOptions, viaName) {
|
170 | /**
|
171 | * If the current item has no sub-tasks, we can return early
|
172 | * with a simple task creation using the global options
|
173 | *
|
174 | * eg:
|
175 | * $ crossbow run sass
|
176 | *
|
177 | * options:
|
178 | * sass:
|
179 | * input: "core.scss"
|
180 | * output: "core.css"
|
181 | *
|
182 | * -> `sass` task will be run with the options
|
183 | * {input: "core.scss", output: "core.css"}
|
184 | */
|
185 | if (!task.subTasks.length) {
|
186 | return getSequenceItemWithOptions(task, trigger, callable, localOptions, viaName);
|
187 | }
|
188 | /**
|
189 | * Get lookup keys for this task
|
190 | */
|
191 | var lookupKeys = getLookupKeys(task.subTasks, localOptions);
|
192 | /**
|
193 | * Now generate 1 task per lookup key.
|
194 | */
|
195 | var group = lookupKeys.reduce(function (acc, optionKey) {
|
196 | /**
|
197 | * `optionKey` here will be a string that represented the subTask
|
198 | * name, so we use that to try and find a child key
|
199 | * in the options that matched it.
|
200 | * */
|
201 | var currentOptionObject = _.merge({}, localOptions._default, _.get(localOptions, optionKey));
|
202 | var sequenceItems = getSequenceItemWithOptions(task, trigger, callable, currentOptionObject, optionKey)
|
203 | .map(function (seqItem) {
|
204 | seqItem.subTaskName = optionKey;
|
205 | return seqItem;
|
206 | });
|
207 | return acc.concat(sequenceItems);
|
208 | }, []);
|
209 | /**
|
210 | * Don't create a 'group' if we're only talking about 1 item
|
211 | */
|
212 | if (group.length === 1) {
|
213 | return group;
|
214 | }
|
215 | if (task.runMode === task_resolve_1.TaskRunModes.parallel) {
|
216 | return [task_sequence_factories_1.createSequenceParallelGroup({
|
217 | taskName: task.taskName,
|
218 | items: group,
|
219 | skipped: task.skipped
|
220 | })];
|
221 | }
|
222 | /**
|
223 | * If the current task was marked as `series`, all immediate child tasks
|
224 | * will be queued and run in series - each waiting until the previous
|
225 | * one has completed
|
226 | */
|
227 | if (task.runMode === task_resolve_1.TaskRunModes.series) {
|
228 | return [task_sequence_factories_1.createSequenceSeriesGroup({
|
229 | taskName: task.taskName,
|
230 | items: group,
|
231 | skipped: task.skipped
|
232 | })];
|
233 | }
|
234 | }
|
235 | function getSequenceItemWithOptions(task, trigger, imported, options, viaName) {
|
236 | /**
|
237 | * Merge incoming options with query + flags
|
238 | * eg:
|
239 | * $ sass?input=css/core.css --production
|
240 | * -> sass
|
241 | * input: css/core.css
|
242 | * production: true
|
243 | */
|
244 | var mergedOptionsWithQuery = _.merge({}, options, task.options, task.query, task.flags);
|
245 | /**
|
246 | * If the module did not export a function, but has a 'tasks'
|
247 | * property that is an array, use each function from it
|
248 | * eg:
|
249 | * module.exports.tasks = [sass, cssmin, version-rev]
|
250 | */
|
251 | if (imported.tasks && Array.isArray(imported.tasks)) {
|
252 | return imported.tasks.map(function (importedFn, i) {
|
253 | return task_sequence_factories_1.createSequenceTaskItem({
|
254 | fnName: getFunctionName(imported, i + 1),
|
255 | factory: importedFn,
|
256 | task: task,
|
257 | options: mergedOptionsWithQuery,
|
258 | viaName: viaName
|
259 | });
|
260 | });
|
261 | }
|
262 | /**
|
263 | * If the module exported a function, use that as the factory
|
264 | * and return a single task for it.
|
265 | * eg:
|
266 | * module.exports = function runSass() {}
|
267 | */
|
268 | if (typeof imported === "function") {
|
269 | return [task_sequence_factories_1.createSequenceTaskItem({
|
270 | fnName: getFunctionName(imported, 0),
|
271 | factory: imported,
|
272 | task: task,
|
273 | options: mergedOptionsWithQuery,
|
274 | viaName: viaName
|
275 | })];
|
276 | }
|
277 | }
|
278 | /**
|
279 | * For reporting purposes, try to 'name' a function
|
280 | */
|
281 | function getFunctionName(fn, count) {
|
282 | if (count === void 0) { count = 0; }
|
283 | if (fn.name === undefined) {
|
284 | return "Anonymous Function " + count;
|
285 | }
|
286 | return fn.name;
|
287 | }
|
288 | /**
|
289 | * ******************
|
290 | * Where the **--~~Magic~~--** happens!!!
|
291 | * ******************
|
292 | *
|
293 | * Creating a task runner in crossbow is really about
|
294 | * wrapping the process of running the tasks in a way
|
295 | * that allows comprehensive logging/reporting
|
296 | *
|
297 | * Series & Parallel have different semantics and are
|
298 | * therefor handled separately.
|
299 | *
|
300 | * Note that everything here is completely lazy and
|
301 | * nothing will be executed until a user calls subscribe
|
302 | */
|
303 | function createRunner(items, trigger) {
|
304 | return {
|
305 | sequence: items,
|
306 | series: function (ctx) {
|
307 | if (!ctx)
|
308 | ctx = Immutable.Map({});
|
309 | var flattened = createObservableTree(items, [], false, ctx);
|
310 | var run = Observable
|
311 | .from(flattened)
|
312 | .concatAll()
|
313 | .catch(function (x) { return Rx.Observable.empty(); });
|
314 | return run;
|
315 | },
|
316 | parallel: function (ctx) {
|
317 | if (!ctx)
|
318 | ctx = Immutable.Map({});
|
319 | var flattened = createObservableTree(items, [], true, ctx);
|
320 | var run = Observable.from(flattened).mergeAll();
|
321 | return run;
|
322 | }
|
323 | };
|
324 | /**
|
325 | * Any task in 'Parallel' run mode that throws an
|
326 | * error should not adversely affect sibling tasks
|
327 | */
|
328 | function shouldCatch(trigger) {
|
329 | return trigger.config.runMode === task_resolve_1.TaskRunModes.parallel;
|
330 | }
|
331 | /**
|
332 | * Create a nested tree of Observables that can contain tasks
|
333 | * alongside parallel/series groups. To understand how this works
|
334 | * you can think of the following to be an accurate representation of
|
335 | * what this function produces:
|
336 | *
|
337 | * const out = [
|
338 | Observable.concat(
|
339 | task1(),
|
340 | task2()
|
341 | ),
|
342 | Observable.concat(
|
343 | task3(),
|
344 | task4(),
|
345 | Observable.concat(
|
346 | task5(),
|
347 | task6(),
|
348 | task7()
|
349 | )
|
350 | )
|
351 | ];
|
352 | *
|
353 | */
|
354 | function createObservableTree(items, initial, addCatch, ctx) {
|
355 | if (addCatch === void 0) { addCatch = false; }
|
356 | return items.reduce(function (all, item) {
|
357 | var output;
|
358 | /**
|
359 | * If the current task was marked as `parallel`, all immediate children
|
360 | * of (this task) will be run in `parallel`
|
361 | */
|
362 | if (item.type === task_sequence_factories_1.SequenceItemTypes.ParallelGroup) {
|
363 | output = Observable.merge(createObservableTree(item.items, [], shouldCatch(trigger), ctx));
|
364 | }
|
365 | /**
|
366 | * If the current task was marked as `series`, all immediate child tasks
|
367 | * will be queued and run in series - each waiting until the previous
|
368 | * one has completed
|
369 | */
|
370 | if (item.type === task_sequence_factories_1.SequenceItemTypes.SeriesGroup) {
|
371 | output = Observable.concat(createObservableTree(item.items, [], false, ctx));
|
372 | }
|
373 | /**
|
374 | * Finally is item is a task, create an observable for it.
|
375 | */
|
376 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task && item.factory) {
|
377 | output = task_runner_1.createObservableFromSequenceItem(item, trigger, ctx);
|
378 | }
|
379 | /**
|
380 | * Should we add a catch clause to this item to enable
|
381 | * siblings to continue when a task errors
|
382 | */
|
383 | if (addCatch || !trigger.config.fail) {
|
384 | return all.concat(output.catch(function (x) { return Rx.Observable.empty(); }));
|
385 | }
|
386 | return all.concat(output);
|
387 | }, initial);
|
388 | }
|
389 | }
|
390 | exports.createRunner = createRunner;
|
391 | /**
|
392 | * From user input, try to locate a options object
|
393 | */
|
394 | function loadTopLevelOptions(task, trigger) {
|
395 | // todo - more robust way of matching options -> tasks
|
396 | var fullMatch = _.get(trigger.input.options, [task.taskName]);
|
397 | if (fullMatch !== undefined) {
|
398 | /**
|
399 | * If this item was given as top-level + options
|
400 | * just return the options here
|
401 | */
|
402 | if (fullMatch.options && fullMatch.tasks) {
|
403 | return fullMatch.options;
|
404 | }
|
405 | /**
|
406 | * If this task has a _default key, don't pass
|
407 | * all the options in, just pass the stuff under default
|
408 | */
|
409 | if (task.subTasks.length === 0 && fullMatch._default !== undefined) {
|
410 | return fullMatch._default;
|
411 | }
|
412 | return fullMatch;
|
413 | }
|
414 | if (task_utils_1.isInternal(task.rawInput)) {
|
415 | var lookup = task.taskName.replace(/(.+?)_internal_fn_\d{0,10}/, "");
|
416 | var fromInternal = _.get(trigger.input.options, [lookup]);
|
417 | if (fromInternal !== undefined) {
|
418 | return fromInternal;
|
419 | }
|
420 | }
|
421 | return {};
|
422 | }
|
423 | /**
|
424 | * After a bunch of tasks have run, we need to link up task-ended reports
|
425 | * with their original position in the sequence. This will allow us to
|
426 | * reconstruct the task render-tree but also show any tasks that errored
|
427 | * or did not complete
|
428 | * @param sequence
|
429 | * @param reports
|
430 | * @returns {*}
|
431 | */
|
432 | function decorateSequenceWithReports(sequence, reports) {
|
433 | return addMany(sequence, []);
|
434 | function addMany(sequence, initial) {
|
435 | return sequence.reduce(function (all, item) {
|
436 | var c = _.assign({}, item);
|
437 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
438 | c.stats = getMergedStats(item, reports);
|
439 | return all.concat(c);
|
440 | }
|
441 | else {
|
442 | c.items = addMany(item.items, []);
|
443 | return all.concat(c);
|
444 | }
|
445 | }, initial);
|
446 | }
|
447 | }
|
448 | exports.decorateSequenceWithReports = decorateSequenceWithReports;
|
449 | /**
|
450 | * Look at every item in the sequence tree and count how many
|
451 | * error have occured
|
452 | */
|
453 | function countSequenceErrors(items) {
|
454 | return items.reduce(function (acc, item) {
|
455 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
456 | var errors = _.get(item, "stats.errors", []);
|
457 | if (errors.length) {
|
458 | return acc + errors.length;
|
459 | }
|
460 | return acc;
|
461 | }
|
462 | return acc + countSequenceErrors(item.items);
|
463 | }, 0);
|
464 | }
|
465 | exports.countSequenceErrors = countSequenceErrors;
|
466 | function collectSkippedTasks(items, initial) {
|
467 | return items.reduce(function (acc, item) {
|
468 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
469 | if (item.stats.skipped) {
|
470 | return acc.concat(item);
|
471 | }
|
472 | return acc;
|
473 | }
|
474 | return acc.concat(collectSkippedTasks(item.items, []));
|
475 | }, initial);
|
476 | }
|
477 | exports.collectSkippedTasks = collectSkippedTasks;
|
478 | function collectRunnableTasks(items, initial) {
|
479 | return items.reduce(function (acc, item) {
|
480 | if (item.type === task_sequence_factories_1.SequenceItemTypes.Task) {
|
481 | return acc.concat(item);
|
482 | }
|
483 | return acc.concat(collectRunnableTasks(item.items, []));
|
484 | }, initial);
|
485 | }
|
486 | exports.collectRunnableTasks = collectRunnableTasks;
|
487 | /**
|
488 | * Look at the reports array to find stats linked to a
|
489 | * given task
|
490 | */
|
491 | function getMergedStats(item, reports) {
|
492 | var match = reports.filter(function (report) {
|
493 | return report.item.seqUID === item.seqUID;
|
494 | });
|
495 | var start = match.filter(function (x) { return x.type === task_runner_1.TaskReportType.start; })[0];
|
496 | var error = match.filter(function (x) { return x.type === task_runner_1.TaskReportType.error; })[0];
|
497 | var end = match.filter(function (x) { return x.type === task_runner_1.TaskReportType.end; })[0];
|
498 | if (start && end) {
|
499 | return _.assign({}, start.stats, end.stats);
|
500 | }
|
501 | if (start && error) {
|
502 | var duration = error.stats.endTime - start.stats.startTime;
|
503 | return _.assign({}, start.stats, error.stats, { duration: duration });
|
504 | }
|
505 | if (start) {
|
506 | return _.assign({}, start.stats);
|
507 | }
|
508 | return { item: item, errors: [] };
|
509 | }
|
510 | /**
|
511 | * When we know a task has `subTasks` we need to check if
|
512 | * if the first entry in the subTasks array is a `*` - then
|
513 | * the user wants to run all tasks under this options
|
514 | * object. So we need to get the keys and use each one as a lookup
|
515 | * on the local options. (minus any excluded tasks)
|
516 | *
|
517 | * eg:
|
518 | * $ crossbow run sass:*
|
519 | *
|
520 | * options:
|
521 | * sass:
|
522 | * site: {input: "core.scss"}
|
523 | * debug: {input: "debug.scss"}
|
524 | *
|
525 | * lookupKeys = ['site', 'debug']
|
526 | */
|
527 | var blacklistedSubTaskNames = ["_default"];
|
528 | function getLookupKeys(subTasks, topLevelObject) {
|
529 | if (subTasks[0] === "*") {
|
530 | return Object.keys(topLevelObject)
|
531 | .filter(function (x) { return blacklistedSubTaskNames.indexOf(x) === -1; });
|
532 | }
|
533 | return subTasks;
|
534 | }
|
535 | //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.sequence.js","sourceRoot":"","sources":["../src/task.sequence.ts"],"names":[],"mappings":"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"} |
\ | No newline at end of file |