bob.js

  1. "use strict";
  2. import async from 'async';
  3. import config from './config.js';
  4. import jazz from 'jazz';
  5. import p from 'path';
  6. import runner from './runner.js';
  7. import task from './task.js';
  8. import util from 'util';
  10. class Bob {
  12.   /**
  13.    * Constructor for initialising Bob.
  14.    *
  15.    * @param {Object} opts: optional
  16.    * - appDir: directory where the userland application calls Bob from
  17.    * - bobDir: directory where Bob's installation is located
  18.    * - appName: name of the userland application (retrieved from its package.json)
  19.    * - appVersion: version value of the userland application (retrieved from its package.json)
  20.    * - bobMode: either `human` or `robot`, when you are a robot - you have to declare yourself :-]
  21.    * - quiet: when true, only display task name and command, but without the command output
  22.    */
  23.   constructor(opts) {
  24.     this.opts = opts;
  25.   }
  27.   /**
  28.    * Bob is goin' to work!
  29.    * Execute specified tasks
  30.    *
  31.    * @param {Array} taskNames: an array of task names
  32.    * @param {Function} cb: standard cb(err, result) callback
  33.    */
  34.   build(taskNames, cb) {
  35.     const EXEC_OPTS = {
  36.       cwd: this.opts.appDir,
  37.       quiet: this.opts.quiet,
  38.       maxBuffer: this.opts.maxBufferInKb * 1024
  39.     };
  40.     const self = this;
  42.     this._init(taskNames, (err, settings) => {
  43.       if (err) { cb(err); } else {
  44.         self._commands(taskNames, settings, (err, commands) => {
  45.           if (err) { cb(err); } else {
  46.             runner.execSeries(commands, EXEC_OPTS, cb);
  47.           }
  48.         });
  49.       }
  50.     });
  51.   }
  53.   /**
  54.    * Load Bob task files and application config file, and install optional dependencies, all in parallel.
  55.    *
  56.    * @param {Array} taskNames: an array of task names
  57.    * @param {Function} cb: standard cb(err, result) callback
  58.    */
  59.   _init(taskNames, cb) {
  60.     const self = this;
  62.     function loadTask(cb) {
  63.       task.load(taskNames, p.join(self.opts.bobDir, 'conf', 'tasks'), cb);
  64.     }
  65.     function loadConfig(cb) {
  66.       config.load(taskNames, self.opts.appDir, cb);
  67.     }
  68.     async.parallel({ bobTasks: loadTask, appConfig: loadConfig }, cb);
  69.   }
  71.   /**
  72.    * Prepare commands to execute.
  73.    *
  74.    * @param {Array} taskNames: an array of task names
  75.    * @param {Object} settings: tasks and application configs
  76.    * @param {Function} cb: standard cb(err, result) callback
  77.    */
  78.   _commands(taskNames, settings, cb) {
  79.     const TPL_PARAMS = {
  80.       app: this.opts.appDir,
  81.       bob: this.opts.bobDir,
  82.       name: this.opts.appName,
  83.       tmp: this.opts.tmpDir,
  84.       version: this.opts.appVersion
  85.     };
  86.     const bobTasks = settings.bobTasks,
  87.       bobMode = this.opts.bobMode,
  88.       self = this;
  89.     const commands = [];
  91.     taskNames.forEach((taskName) => {
  93.       self._taskTypeNames(taskName, settings).forEach((taskTypeName) => {
  94.         const taskType = bobTasks[taskName].types[taskTypeName];
  95.         Object.keys(taskType).forEach((key) => {
  96.           if (typeof taskType[key] === 'object') {
  97.             taskType[key] = taskType[key][bobMode];
  98.           }
  99.         });
  100.         taskType.preOpts = taskType.preOpts || taskType.opts;
  101.         // strip undefined and null from command elements
  102.         const elems = [taskType.bin, taskType.preOpts, taskType.args, taskType.postOpts].filter(elem => elem);
  103.         commands.push({
  104.           format: util.format(elems.join(' ')),
  105.           meta: {
  106.             task: taskName,
  107.             type: taskTypeName
  108.           }
  109.         });
  110.       });
  111.     });
  113.     const jobs = [];
  114.     commands.forEach((command) => {
  115.       jobs.push((cb) => {
  116.         jazz.compile(command.format).process(TPL_PARAMS, (result) => {
  117.           command.exec = result;
  118.           delete command.format;
  119.           cb(null, command);
  120.         });
  121.       });
  122.     });
  123.     async.parallel(jobs, cb);
  124.   }
  126.   _taskTypeNames(taskName, settings) {
  127.     // NOTE: allow multiple types in application config
  128.     let taskTypeNames =
  129.       (settings.appConfig[taskName] && settings.appConfig[taskName].type) ?
  130.       settings.appConfig[taskName].type :
  131.       settings.bobTasks[taskName].default;
  132.     if (!Array.isArray(taskTypeNames)) {
  133.       taskTypeNames = [taskTypeNames];
  134.     }
  135.     return taskTypeNames;
  136.   }
  137. }
  139. export {
  140.   Bob as default
  141. };