burn/bin/cli.js

Super lightweight JS module/asset loader

#!/usr/bin/env node
(function() {
  // Imports
  var program = require('commander');
  var path = require('path');
  var fs = require('fs');
  var assert = require('assert');
  var colors = require('colors');
  var extend = require('util')._extend;

  // Load core libs
  var rootDir = path.join(path.dirname(fs.realpathSync(__filename)));
  var burn = require(rootDir+'/../index.js');
  var helpers = require(rootDir+'/../lib/helpers.js');

  // Shortcuts
  var ConfigError = burn.exceptions.ConfigError;

  /*
   * CLI functionality
   */
  (function() {

    /*
     * Collect list of items
     */
    function collect(val, items) {
      items.push(val);
      return items;
    }

    /*
     * Parse module/asset names to allow for
     * optional name field
     */
    function collectModuleAsset(value, items) {
      var parts = value.split(":");
      if (parts.length == 1)
        items.push({'src': parts[0]});
      else if (parts.length == 2)
        items.push({'src': parts[1], 'name': parts[0]})
      else
        throw new ConfigError("Invalid name/path: %s".format(value))
      return items;
    }

    // configure CLI prompt
    program
      .version('0.1.3')
      .option('-t, --trace', 'Enable tracebacks (default: false)', false)
      .option('-v, --verbose', 'Enable verbosity (default: false)', false)
      .option('-c, --config <path>', 'Config path (json)', null)
      .option('-b, --basedir <path>', 'Set include base directory (default: cwd)', process.cwd())
      .option('--module [name:]<path>', 'Add module to bundle (required)', collectModuleAsset, [])
      .option('--entry <path>', 'Add entry point to bundle (required)', collect, [])
      .option('--asset [name:]<path>', 'Add asset to bundle', collectModuleAsset, [])
      .option('--out <path>', 'Output path (default: stdout)', null)
      .parse(process.argv);

    // display help if no argments provided
    if (!process.argv.slice(2).length) {
      program.outputHelp();
      return process.exit(1);
    }

    // ensure no arguments have been given
    if (program.args.length) {
      process.stderr.write("error: invalid arguments\r\n".yellow);
      program.outputHelp();
      return process.exit(1);
    }
  })()


  // conditonal logging function
  var log = function(msg) {
    if (!verbose) { return; }
    var msg = new String(msg).toString();
    process.stderr.write(msg+"\r\n");
  }

  // merge with default arguments
  var verbose = program.verbose;
  var options = {
    baseDir: program.basedir
  }
  
  // determine if config is from file
  if (program.config) {
    try {
      var optionsData = JSON.parse(fs.readFileSync(program.config, 'utf8'));
      options = extend(options, optionsData);
    } catch(e) {
      process.stderr.write(String("Could not load config from path: "+program.config).magenta);
      throw e;
    }
  } else {
    var options = {
      modules: program.module,
      assets: program.asset,
      entry: program.entry,
      out: program.out,
      configPath: program.config
    }
  }
  // start compiling
  try {
    var c = burn.compile(options);
    var compiler = c.compiler;
    var result = c.result;
    var resultmeta = c.meta;
  } catch (e) {
    if (e instanceof burn.exceptions.CompileError) {
      process.stderr.write("error: compile failed\r\n".yellow)
      process.stderr.write(String(e.trace).magenta);
    } else {
      throw e;
    }
    process.exit(1);
  }

  // output some stats
  var outputModuleAsset = function(item) {
    if (item.meta.length == 1) {
      log("  [%s] %s".format(item.name.yellow, item.meta[0].absolutePath));
    } else {
      log("  [%s]".format(item.name.yellow));
      item.meta.absolutePath.forEach(function(fpath) {
        log("       %s".format(fpath));
      });
    }
  }

  if (!program.out) {
    process.stdout.write(result+"\r\n")
  }

  if (verbose) {
    // Show modules
    if (Object.keys(compiler.modules).length) {
      log("Modules:".magenta);
      helpers.each(compiler.modules, function(name, item) {
        outputModuleAsset(item);
      });
    }

    // Show assets
    if (Object.keys(compiler.assets).length) {
      log("Assets:".magenta);
      helpers.each(compiler.assets, function(name, item) {
        outputModuleAsset(item);
      });
    }

    log("Entry points:".magenta);
    compiler.entry_order.forEach(function(name) {
      var item = compiler.entry[name];
      outputModuleAsset(item);
    })

    if (resultmeta.outpath) {
      log("Wrote %s bytes to %s".format(String(result.length).yellow, resultmeta.outpath.yellow));
    }
  }

  process.exit(0);
  return;

  // Send out some debug
  //
  //log("  %s: %s".format("base dir".yellow, options.baseDir));


  //
  //log("  [%s] %s".format(module.name.yellow, module.absolutePath));

  // check if we need to write or print
  /*var content = fb.render()
  if (program.out) {
    fs.writeFileSync(program.out, content, 'utf8');
  } else {
    
  }*/

})();