shortcake/lib/shortcake.mjs

Asynchronous invoke and other goodies for cake.

import 'postmortem/register';
import exec from 'executive';
import path from 'path';
import vigil from 'vigil';
import cp from 'cp';
import fs from 'fs';
import chalk from 'chalk';

// src/utils.coffee
var isFunction = function(fn) {
  return typeof fn === 'function';
};



var isGeneratorFn = function(fn) {
  var ref;
  if (!isFunction(fn)) {
    return false;
  }
  return (fn != null ? (ref = fn.constructor) != null ? ref.name : void 0 : void 0) === 'GeneratorFunction';
};

var isPromise = function(p) {
  return isFunction(p != null ? p.then : void 0);
};

var isArray = function(a) {
  return Array.isArray(a);
};

var isString = function(s) {
  return typeof s === 'string';
};

// src/cp.coffee
var cp$1 = function(src, dst, opts, cb) {
  var p, ref;
  if (isFunction(opts)) {
    ref = [{}, opts], opts = ref[0], cb = ref[1];
  }
  if (opts == null) {
    opts = {};
  }
  p = new Promise(function(resolve, reject) {
    return fs.stat(dst, function(err, stats) {
      if (stats.isDirectory) {
        dst = path.join(dst, path.basename(src));
      }
      return cp(src, dst, function(err) {
        if (err != null) {
          return reject(err);
        } else {
          return resolve();
        }
      });
    });
  });
  p.callback(cb);
  return p;
};

// src/cake.coffee
var cake;
var cakeInvoke;
var cakeOption;
var cakeTask;

if (global.task == null) {
  require('coffee-script/lib/coffee-script/cake');
}

cakeInvoke = global.invoke;

cakeOption = global.option;

cakeTask = global.task;

var cake$1 = cake = {
  invoke: cakeInvoke,
  option: cakeOption,
  task: cakeTask
};

// src/log.coffee
var k;
var logger;
var methods;
var pretty;
var ref;
var v;
var verbose;
var wrapper$1;
var slice = [].slice;

verbose = (ref = process.env.VERBOSE) != null ? ref : false;

pretty = function(obj) {
  return JSON.stringify(obj, null, 2);
};

logger = function(method, color) {
  var prefix;
  prefix = chalk[color](method);
  return function() {
    var arg, args, i, len, msg;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    if (!verbose) {
      return;
    }
    msg = prefix;
    for (i = 0, len = args.length; i < len; i++) {
      arg = args[i];
      if (isString(arg)) {
        msg += ' ' + arg;
      } else {
        msg += '\n' + pretty(arg);
      }
    }
    return console.log(msg);
  };
};

methods = {
  debug: 'blue',
  info: 'white',
  warn: 'yellow',
  error: 'red',
  bebop: 'black',
  modified: 'cyan',
  compiled: 'blue'
};

wrapper$1 = logger('info', 'white');

for (k in methods) {
  v = methods[k];
  wrapper$1[k] = logger(k, v);
}

wrapper$1.verbose = function(bool) {
  if (bool == null) {
    bool = !verbose;
  }
  return verbose = bool;
};

var log = wrapper$1;

// src/running.coffee
var running;
var runningTasks;

runningTasks = {};

running = function(name) {
  return runningTasks[name];
};

running.start = function(name) {
  log.info('running', name);
  return runningTasks[name] = true;
};

running.stop = function(name) {
  log.info('stopped', name);
  return runningTasks[name] = false;
};

var running$1 = running;

// src/invoke/async.coffee
var invokeAsync;

invokeAsync = function(name, action, opts, cb) {
  var done;
  log.debug('invokeAsync', name);
  running$1.start(name);
  done = function() {
    running$1.stop(name);
    return cb.apply(null, arguments);
  };
  if (opts != null) {
    return action(opts, done);
  } else {
    return action(done);
  }
};

var invokeAsync$1 = invokeAsync;

// src/invoke/generator.coffee
var invokeGenerator;

invokeGenerator = function(name, action, opts, cb) {
  var done, gen, last, next, prev;
  log.debug('invokeGenerator', name);
  running$1.start(name);
  gen = action(opts);
  last = null;
  prev = null;
  done = function(err) {
    running$1.stop(name);
    if (err != null) {
      console.error(err.stack);
    }
    return cb(err, last != null ? last : prev);
  };
  next = function(value) {
    var err, promise, res;
    try {
      res = gen.next(value);
    } catch (error) {
      err = error;
      console.error(err.stack);
      return done(err);
    }
    prev = last;
    last = res.value;
    if (isPromise(promise = res.value)) {
      return promise.then(function(value) {
        return next(value);
      })["catch"](function(err) {
        return done(err);
      });
    } else if (!res.done) {
      return next(res.value);
    } else {
      return done();
    }
  };
  return next();
};

var invokeGenerator$1 = invokeGenerator;

// src/invoke/sync.coffee
var invokeSync;

invokeSync = function(name, action, opts, cb) {
  var promise, ret;
  log.debug('invokeSync', name);
  running$1.start(name);
  ret = action(opts);
  if (isPromise(promise = ret)) {
    return promise.then(function(value) {
      running$1.stop(name);
      return cb(null, value);
    })["catch"](function(err) {
      running$1.stop(name);
      return cb(err);
    });
  } else {
    running$1.stop(name);
    return cb(null, ret);
  }
};

var invokeSync$1 = invokeSync;

// src/invoke/serial.coffee
var invokeSerial;

invokeSerial = function(tasks, opts, cb) {
  var serial;
  log.debug('invokeSerial', tasks, opts);
  serial = function(cb) {
    var next;
    next = function(err) {
      if (err != null) {
        return cb(err);
      }
      if (tasks.length) {
        return invoke$2(tasks.shift(), opts, next);
      } else {
        return cb();
      }
    };
    return next();
  };
  if (isFunction(cb)) {
    return serial(cb);
  }
  return new Promise(function(resolve, reject) {
    return serial(function(err) {
      if (err != null) {
        reject(err);
      }
      resolve();
      if (isFunction(cb)) {
        return cb(err);
      }
    });
  });
};

var serial = invokeSerial;

// src/tasks.coffee
var tasks;

tasks = {};

tasks.has = function(key) {
  return tasks[key] != null;
};

var tasks$1 = tasks;

// src/invoke/invoke.coffee
var invoke$1;
var invoked;

invoked = {};

invoke$1 = function(name, opts, cb) {
  var action, deps, done, invokeAction, options, ref;
  log.debug('invoke');
  if (invoked[name]) {
    return;
  }
  invoked[name] = true;
  cake$1.invoke(name);
  ref = tasks$1[name], action = ref.action, deps = ref.deps, options = ref.options;
  opts = Object.assign(options, opts);
  done = function(err) {
    invoked = {};
    if (isFunction(cb)) {
      return cb(err);
    }
  };
  invokeAction = function(err) {
    if (err != null) {
      return done(err);
    }
    if (isGeneratorFn(action)) {
      return invokeGenerator$1(name, action, opts, done);
    }
    if (action.length === 2) {
      return invokeAsync$1(name, action, opts, done);
    }
    if (/^function \((callback|cb|done|next)\)/.test(action)) {
      return invokeAsync$1(name, action, null, done);
    }
    return invokeSync$1(name, action, opts, done);
  };
  return serial(deps, opts, invokeAction);
  return invokeAction();
};

var invoke$2 = invoke$1;

// src/invoke/parallel.coffee
var invokeParallel;

invokeParallel = function(tasks, opts, cb) {
  var parallel;
  log.debug('invokeParallel', tasks, opts);
  parallel = function(cb) {
    var done, i, len, results, task;
    done = 0;
    results = [];
    for (i = 0, len = tasks.length; i < len; i++) {
      task = tasks[i];
      results.push(invoke$2(task, opts, function() {
        if (++done === tasks.length) {
          return cb();
        }
      }));
    }
    return results;
  };
  if (isFunction(cb)) {
    return parallel(cb);
  }
  return new Promise(function(resolve, reject) {
    return parallel(function(err) {
      if (err != null) {
        reject(err);
      }
      resolve();
      if (isFunction(cb)) {
        return cb(err);
      }
    });
  });
};

var parallel = invokeParallel;

// src/invoke/index.coffee
var wrap;
var wrapper;

wrap = function(fn) {
  return function(tasks, opts, cb) {
    var ref;
    if (!isArray(tasks)) {
      tasks = [tasks];
    }
    if (isFunction(opts)) {
      ref = [opts, {}], cb = ref[0], opts = ref[1];
    }
    if (opts == null) {
      opts = {};
    }
    return fn(tasks, opts, cb);
  };
};

wrapper = wrap(serial);

wrapper.serial = wrapper;

wrapper.parallel = wrap(parallel);

var invoke = wrapper;

// src/task.coffee
var task = function(name, description, deps, action) {
  var ref, ref1, ref2;
  if (isArray(description)) {
    if (isFunction(deps)) {
      action = deps;
    }
    ref = ['', description], description = ref[0], deps = ref[1];
  }
  if (isFunction(description)) {
    ref1 = [description, '', []], action = ref1[0], description = ref1[1], deps = ref1[2];
  }
  if (isFunction(deps)) {
    ref2 = [deps, []], action = ref2[0], deps = ref2[1];
  }
  if (!isFunction(action)) {
    action = function() {};
  }
  tasks$1[name] = {
    name: name,
    description: description,
    deps: deps,
    action: action
  };
  log.debug('added task', tasks$1[name]);
  return cake$1.task(name, description, function(options) {
    return tasks$1[name].options = options;
  });
};

// src/use.coffee
var use = function(pkg, opts) {
  if (opts == null) {
    opts = {};
  }
  if (isString(pkg)) {
    pkg = require(pkg);
  }
  if (isFunction(pkg)) {
    return pkg(opts);
  }
};

// src/index.coffee
var binPath;

binPath = path.join(process.cwd(), 'node_modules/', '.bin');

process.env.PATH = ([binPath].concat(process.env.PATH.split(':'))).join(':');

global.cp = cp$1;

global.exec = exec;

global.invoke = invoke;

global.running = running$1;

global.task = task;

global.tasks = tasks$1;

global.use = use;

global.walk = vigil.walk;

global.watch = vigil.watch;

export { cp$1 as cp, exec, invoke, running$1 as running, task, tasks$1 as tasks, use };
//# sourceMappingURL=shortcake.mjs.map