_duo

#!/usr/bin/env node

/**
 * Module dependencies.
 */

var convert = require('convert-source-map');
var Command = require('commander').Command;
var relative = require('path').relative;
var Logger = require('stream-log');
var util = require('../lib/util');
var stdin = require('get-stdin');
var Watch = require('duo-watch');
var pkg = require('../package');
var Batch = require('batch');
var stdout = process.stdout;
var hasError = false;
var packages = {};

/**
 * Program.
 */

var program = new Command('duo')
  .version(pkg.version)
  .usage('[options] command|[file, ...]')
  .option('-c, --copy', 'opt to copy files instead of symlink', false)
  .option('-C, --no-cache', 'enable or disable the cache during build', true)
  .option('-d, --development', 'include development dependencies and include an inline source-map', false)
  .option('-g, --global <name>', 'expose entry as a global <name>', null)
  .option('-e, --external-source-maps', 'generate a source-map for the input entry file', false)
  .option('-o, --output <dir>', 'set the output directory, defaulted to build/', null)
  .option('-q, --quiet', 'only print to stderr when there is an error', false)
  .option('-r, --root <dir>', 'root directory to build from.', null)
  .option('-t, --type <type>', 'set the entry type', null)
  .option('-u, --use <plugin>', 'use transform plugin(s)', util.collect, [])
  .option('-U, --update', 'always update dependencies', false)
  .option('-v, --verbose', 'show as much logs as possible', false)
  .option('-w, --watch', 'watch for changes and rebuild', false)
  .option('-s, --standalone <standalone>', 'outputs standalone javascript umd <standalone>', '')
  .option('-S, --stdout', 'outputs build to stdout', false)
  .parse(process.argv);

/**
 * Help.
 */

program.on('--help', function () {
  console.log('  Usage:');
  console.log();
  console.log('  # build all files to build/');
  console.log('  $ duo *.{js,css}');
  console.log();
  console.log('  # build all files to the out/ folder');
  console.log('  $ duo --output out/ *.{js,css}');
  console.log();
  console.log('  # build from stdin and output out.css');
  console.log('  $ duo < in.css > out.css');
  console.log();
  console.log('  # build to out.js using stdout');
  console.log('  $ duo --stdout in.js > out.js');
  console.log();
  console.log('  # build using a plugin');
  console.log('  $ npm install duo-whitespace');
  console.log('  $ duo --use duo-whitespace in.styl > out.css');
  console.log();
  console.log('  Commands:');
  console.log();
  console.log('    install      install dependencies for a file.');
  console.log('    ls           list all dependencies.');
  console.log('    duplicates   show all duplicates.');
  console.log();
  process.exit(0);
});

/**
 * Logger.
 */

var logger = new Logger(process.stderr)
  // success
  .type('wrote', '32m')
  // info
  .type('building', '36m')
  .type('built', '36m')
  .type('installing', '36m')
  .type('installed', '36m')
  .type('finding', '36m')
  .type('found', '36m')
  .type('using', '36m');

/**
 * Error.
 */

logger.type('error', '31m', function () {
  hasError = true;
});

/**
 * End logger output after process exit.
 */

process.on('exit', function () {
  if (!program.quiet) logger.end();
  if (hasError) process.exit(1);
});


/**
 * Quiet flag.
 */

var quiet = program.quiet;

/**
 * Verbose flag.
 */

var verbose = program.verbose;

/**
 * Only quite *or* verbose should be enabled, never both.
 */

if (quiet && verbose) {
  logger.error('cannot use both quiet and verbose mode simultaneously');
  return;
}

/**
 * Root.
 */

var root = util.findroot(program.root);

/**
 * Asset path.
 */

var outdir = program.output;

/**
 * Watching.
 */

var watching = false;

/**
 * Plugins.
 */

try {
  var plugins = util.plugins(root, program.use);
} catch (err) {
  error(err);
  return;
}

/**
 * Source maps.
 */

var sourceMap = sourcemap(program.development, program.externalSourceMaps);

/**
 * GitHub Authentication.
 */

var token = util.token();

/**
 * Stdout.
 */

if (program.stdout && program.args.length > 1) {
  logger.error('cannot use stdout with multiple entries');
  return;
}

/**
 * End logger output.
 */

process.on('exit', function () {
  if (!quiet) logger.end();
  if (hasError) process.exit(1);
});

/**
 * Actions.
 */

if (program.stdout && program.args.length) print(program.args[0]);
else if (program.args.length) write(util.entries(root, program.args));
else if (!process.stdin.isTTY) input();
else program.help();

/**
 * Accept standard input.
 */

function input() {
  stdin(function (src) {
    var type = program.type || util.type(src);
    if (!type) return logger.error('could not detect the file type');
    var duo = create(root).entry(src, type);

    // only inline source-maps supported for stdout (if enabled at all)
    if (sourceMap) duo.sourceMap('inline');

    duo.run(function (err, results) {
      if (err) return error(err);
      stdout.write(results.code);
      if (results.map) {
        stdout.write('\n\n');
        stdout.write(convert.fromObject(results.map).toComment());
      }
      process.exit(0);
    });
  });
}

/**
 * Print to stdout.
 *
 * @param {String} entry
 */

function print(entry) {
  var duo = create(entry);

  // only inline source-maps supported for stdout (if enabled at all)
  if (sourceMap) duo.sourceMap('inline');

  duo.run(function (err, results) {
    if (err) return error(err);
    if (results.code) stdout.write(results.code);
    if (results.map) {
      stdout.write('\n\n');
      stdout.write(convert.fromObject(results.map).toComment());
    }

    // watch or exit
    program.watch
      ? watch(print)
      : process.exit(0);
  });
}

/**
 * Write the entries.
 *
 * @param {Array} entries
 */

function write(entries) {
  if (typeof entries === 'string') entries = [entries];

  var batch = new Batch();
  var push = batch.push.bind(batch);

  entries
    .map(multiple)
    .map(push);

  batch.end(function (err) {
    if (err) return error(err);

    // watch or exit
    program.watch
      ? watch(write)
      : process.exit(0);
  });

  // write multiple entries to
  // the directory `out`
  function multiple(entry) {
    return function (done) {
      create(entry).write(done);
    };
  }
}

/**
 * Create a duo instance.
 *
 * @param {entry} entry
 * @return {Duo}
 */

function create(entry) {
  var duo = new Duo(root)
    .development(program.development)
    .sourceMap(sourceMap)
    .cache(program.cache)
    .copy(program.copy)
    .update(program.update)
    .token(token)
    .entry(entry);

  // FIXME: cache the packages between all builds in this process
  // this should be handled another way
  duo.packages = packages;

  // standalone
  var name = program.standalone;
  name && duo.standalone(name);

  // global
  program.global && duo.global(program.global);

  // events
  if (!quiet) {
    if (verbose) {
      duo.on('resolving', log('finding'));
      duo.on('resolve', log('found'));
      duo.on('installing', log('installing'));
    }

    duo.on('plugin', log('using'));
    duo.on('install', log('installed'));
    duo.on('running', log('building'));
    duo.on('run', log('built'));
    duo.on('write', log('wrote'));
  }

  // output dir
  outdir && duo.buildTo(outdir);
  program.out && duo.buildTo(program.out);

  // use plugins
  plugins.forEach(duo.use, duo);

  return duo;
}

/**
 * Watch.
 *
 * @param {Function} action
 */

function watch(action) {
  if (watching) return;
  watching = true;
  new Watch(root).watch(action);
}

/**
 * Error.
 */

function error(err) {
  err = typeof err === 'string' ? new Error(err) : err;
  if (err instanceof SyntaxError && err.fileName) {
    var msg = err.message;
    var file = relative(process.cwd(), err.fileName);
    logger.error('Syntax error:', msg, 'in:', file);
  } else {
    logger.error(err.stack);
  }
}

/**
 * Log an event.
 *
 * @param {String} event
 * @return {Function}
 */

function log(event) {
  return function (pkg) {
    pkg = pkg.slug ? pkg.slug() : pkg;
    pkg = 'source.' + (program.type || 'js') === pkg ? 'from stdin' : pkg;
    logger[event](pkg);
  };
}

/**
 * Determine the appropriate source-maps value.
 *
 *  - when `--external-source-maps is on, return `true`
 *  - when `--development` is on, return `'inline'`
 *  - otherwise, return `false`
 *
 * @param {Boolean} development
 * @param {Boolean} external
 * @returns {Boolean|String}
 */

function sourcemap(development, external) {
  if (external) return true;
  if (development) return 'inline';
  return false;
}

/**
 * Lazy-load Duo
 */

function Duo() {
  var duo = require('..');
  return duo.apply(duo, arguments);
}