Plato - lib/bob.js

"use strict";
import async from "async";
import config from "./config.js";
import jazz from "jazz";
import p from "path";
import runner from "./runner.js";
import task from "./task.js";
import util from "util";

class Bob {
  /**
   * Constructor for initialising Bob.
   *
   * @param {Object} opts: optional
   * - appDir: directory where the userland application calls Bob from
   * - bobDir: directory where Bob's installation is located
   * - appName: name of the userland application (retrieved from its package.json)
   * - appVersion: version value of the userland application (retrieved from its package.json)
   * - bobMode: either `human` or `robot`, when you are a robot - you have to declare yourself :-]
   * - quiet: when true, only display task name and command, but without the command output
   */
  constructor(opts) {
    this.opts = opts;
  }

/**
   * Bob is goin' to work!
   * Execute specified tasks
   *
   * @param {Array} taskNames: an array of task names
   * @param {Function} cb: standard cb(err, result) callback
   */
  build(taskNames, cb) {
    const EXEC_OPTS = {
      cwd: this.opts.appDir,
      tmp: this.opts.tmpDir,
      quiet: this.opts.quiet,
      maxBuffer: this.opts.maxBufferInKb * 1024,
    };
    const self = this;

this._init(taskNames, (err, settings) => {
      if (err) {
        cb(err);
      } else {
        self._commands(taskNames, settings, (err, commands) => {
          if (err) {
            cb(err);
          } else {
            runner.execSeries(commands, EXEC_OPTS, cb);
          }
        });
      }
    });
  }

/**
   * Load Bob task files and application config file, and install optional dependencies, all in parallel.
   *
   * @param {Array} taskNames: an array of task names
   * @param {Function} cb: standard cb(err, result) callback
   */
  _init(taskNames, cb) {
    const self = this;

/**
   * Prepare commands to execute.
   *
   * @param {Array} taskNames: an array of task names
   * @param {Object} settings: tasks and application configs
   * @param {Function} cb: standard cb(err, result) callback
   */
  _commands(taskNames, settings, cb) {
    const TPL_PARAMS = {
      app: this.opts.appDir,
      bob: this.opts.bobDir,
      name: this.opts.appName,
      tmp: this.opts.tmpDir,
      version: this.opts.appVersion,
    };
    const bobTasks = settings.bobTasks,
      bobMode = this.opts.bobMode,
      self = this;
    const commands = [];

taskNames.forEach((taskName) => {
      self._taskTypeNames(taskName, settings).forEach((taskTypeName) => {
        const taskType = bobTasks[taskName].types[taskTypeName];
        Object.keys(taskType).forEach((key) => {
          if (typeof taskType[key] === "object") {
            taskType[key] = taskType[key][bobMode];
          }
        });
        taskType.preOpts = taskType.preOpts || taskType.opts;
        // strip undefined and null from command elements
        const elems = [
          taskType.bin,
          taskType.preOpts,
          taskType.args,
          taskType.postOpts,
        ].filter((elem) => elem);
        commands.push({
          format: util.format(elems.join(" ")),
          meta: {
            task: taskName,
            type: taskTypeName,
          },
        });
      });
    });

_taskTypeNames(taskName, settings) {
    // NOTE: allow multiple types in application config
    let taskTypeNames =
      settings.appConfig[taskName] && settings.appConfig[taskName].type
        ? settings.appConfig[taskName].type
        : settings.bobTasks[taskName].default;
    if (!Array.isArray(taskTypeNames)) {
      taskTypeNames = [taskTypeNames];
    }
    return taskTypeNames;
  }
}

export { Bob as default };

lib/bob.js

Maintainability

Lines of code

Difficulty

Estimated Errors

Function weight

By Complexity

By SLOC