whisper/lib/whisper.js

A task-based automation app. Leiningen style.

(function(){
  var doc, opts, path, whisper, log, ref$, allTasks, resolve, loadConfig, findLocalConfig, findConfig, home, loadPackageConfig, whisperConfig, environmentFor, defaultEnvironment, configure, tryRequire, showVersion, showHelp, showUsage, showAlternatives, runTask, args, pkgMeta, task, taskArgs, dir, projectRoot, currentConfig, env, slice$ = [].slice;
  doc = 'Whisper --- A task-based automation app. Leiningen style!\n\nUsage:\n  whisper <task> [<args>...] [options]';
  opts = 'Options:\n  -v, --version           Displays the version and exits.\n  -h, --help              Displays this screen and exits.\n  -d, --directory=<dir>   Directory containing the .whisper to load.\n  -e, --env=<kind>        Defines the configuration environment [default: *].';
  path = require('path');
  whisper = require('./');
  log = require('./log');
  ref$ = require('./tasks'), allTasks = ref$.allTasks, resolve = ref$.resolve;
  ref$ = require('./config'), loadConfig = ref$.loadConfig, findLocalConfig = ref$.findLocalConfig, findConfig = ref$.findConfig, home = ref$.home, loadPackageConfig = ref$.loadPackageConfig, whisperConfig = ref$.whisperConfig;
  ref$ = require('./environment'), environmentFor = ref$.environmentFor, defaultEnvironment = ref$.defaultEnvironment, configure = ref$.configure;
  tryRequire = function(module){
    var e;
    try {
      return require(path.resolve(projectRoot, 'node_modules', module));
    } catch (e$) {
      e = e$;
      return require(path.resolve(home, '.whisper.d', 'node_modules', module));
    }
  };
  showVersion = function(version){
    return console.log("whisper " + version);
  };
  showHelp = function(){
    return console.log(doc + '\n\n' + opts);
  };
  showUsage = function(env){
    console.log(doc + '\n');
    return resolve('list').execute(env, []);
  };
  showAlternatives = function(task){
    return log.fatal("The task \"" + task + "\" has not been registered.");
  };
  runTask = function(task, env, taskArgs){
    var ref$, e;
    try {
      return (ref$ = resolve(task)).execute.apply(ref$, [env].concat(slice$.call(taskArgs)));
    } catch (e$) {
      e = e$;
      switch (e.name) {
      case '<inexistent-task-e>':
        return showAlternatives(task);
      default:
        throw e;
      }
    }
  };
  args = require('optimist').options('v', {
    alias: 'version'
  }).options('h', {
    alias: 'help'
  }).options('d', {
    alias: 'directory'
  }).options('e', {
    alias: 'env',
    'default': '*'
  }).boolean('v').boolean('h').string('f').string('e').argv;
  pkgMeta = require('../package');
  task = args._.shift();
  taskArgs = args._;
  dir = args.directory || '.';
  projectRoot = findLocalConfig(dir);
  currentConfig = loadPackageConfig(dir).map(whisperConfig).reduce(curry$(function(x$, y$){
    return import$(x$, y$);
  }), {});
  configure({
    whisper: import$({
      command: args,
      root: projectRoot
    }, currentConfig)
  });
  if (projectRoot) {
    process.chdir(path.dirname(projectRoot));
  }
  whisper.log = log.derive({
    prefix: task
  });
  if ((ref$ = currentConfig.plugins) != null) {
    ref$.forEach(function(it){
      return tryRequire(it)(whisper);
    });
  }
  require('./core')(whisper);
  loadConfig(dir).forEach(function(config){
    return config(whisper);
  });
  env = args.env
    ? environmentFor(args.env)
    : defaultEnvironment();
  switch (false) {
  case !args.version:
    showVersion(pkgMeta.version);
    break;
  case !args.help:
    showHelp();
    break;
  case !task:
    runTask(task, env, taskArgs);
    break;
  default:
    showUsage(env);
  }
  function import$(obj, src){
    var own = {}.hasOwnProperty;
    for (var key in src) if (own.call(src, key)) obj[key] = src[key];
    return obj;
  }
  function curry$(f, bound){
    var context,
    _curry = function(args) {
      return f.length > 1 ? function(){
        var params = args ? args.concat() : [];
        context = bound ? context || this : this;
        return params.push.apply(params, arguments) <
            f.length && arguments.length ?
          _curry.call(context, params) : f.apply(context, params);
      } : f;
    };
    return _curry();
  }
}).call(this);