node_modules/wscat/node_modules/commander/index.js

   1 /**
   2  * Module dependencies.
   3  */
   4
   5 var EventEmitter = require('events').EventEmitter;
   6 var spawn = require('child_process').spawn;
   7 var path = require('path');
   8 var dirname = path.dirname;
   9 var basename = path.basename;
  10 var fs = require('fs');
  11
  12 /**
  13  * Inherit `Command` from `EventEmitter.prototype`.
  14  */
  15
  16 require('util').inherits(Command, EventEmitter);
  17
  18 /**
  19  * Expose the root command.
  20  */
  21
  22 exports = module.exports = new Command();
  23
  24 /**
  25  * Expose `Command`.
  26  */
  27
  28 exports.Command = Command;
  29
  30 /**
  31  * Expose `Option`.
  32  */
  33
  34 exports.Option = Option;
  35
  36 /**
  37  * Initialize a new `Option` with the given `flags` and `description`.
  38  *
  39  * @param {String} flags
  40  * @param {String} description
  41  * @api public
  42  */
  43
  44 function Option(flags, description) {
  45   this.flags = flags;
  46   this.required = ~flags.indexOf('<');
  47   this.optional = ~flags.indexOf('[');
  48   this.bool = !~flags.indexOf('-no-');
  49   flags = flags.split(/[ ,|]+/);
  50   if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift();
  51   this.long = flags.shift();
  52   this.description = description || '';
  53 }
  54
  55 /**
  56  * Return option name.
  57  *
  58  * @return {String}
  59  * @api private
  60  */
  61
  62 Option.prototype.name = function() {
  63   return this.long
  64     .replace('--', '')
  65     .replace('no-', '');
  66 };
  67
  68 /**
  69  * Return option name, in a camelcase format that can be used
  70  * as a object attribute key.
  71  *
  72  * @return {String}
  73  * @api private
  74  */
  75
  76 Option.prototype.attributeName = function() {
  77   return camelcase(this.name());
  78 };
  79
  80 /**
  81  * Check if `arg` matches the short or long flag.
  82  *
  83  * @param {String} arg
  84  * @return {Boolean}
  85  * @api private
  86  */
  87
  88 Option.prototype.is = function(arg) {
  89   return this.short === arg || this.long === arg;
  90 };
  91
  92 /**
  93  * Initialize a new `Command`.
  94  *
  95  * @param {String} name
  96  * @api public
  97  */
  98
  99 function Command(name) {
 100   this.commands = [];
 101   this.options = [];
 102   this._execs = {};
 103   this._allowUnknownOption = false;
 104   this._args = [];
 105   this._name = name || '';
 106 }
 107
 108 /**
 109  * Add command `name`.
 110  *
 111  * The `.action()` callback is invoked when the
 112  * command `name` is specified via __ARGV__,
 113  * and the remaining arguments are applied to the
 114  * function for access.
 115  *
 116  * When the `name` is "*" an un-matched command
 117  * will be passed as the first arg, followed by
 118  * the rest of __ARGV__ remaining.
 119  *
 120  * Examples:
 121  *
 122  *      program
 123  *        .version('0.0.1')
 124  *        .option('-C, --chdir <path>', 'change the working directory')
 125  *        .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
 126  *        .option('-T, --no-tests', 'ignore test hook')
 127  *
 128  *      program
 129  *        .command('setup')
 130  *        .description('run remote setup commands')
 131  *        .action(function() {
 132  *          console.log('setup');
 133  *        });
 134  *
 135  *      program
 136  *        .command('exec <cmd>')
 137  *        .description('run the given remote command')
 138  *        .action(function(cmd) {
 139  *          console.log('exec "%s"', cmd);
 140  *        });
 141  *
 142  *      program
 143  *        .command('teardown <dir> [otherDirs...]')
 144  *        .description('run teardown commands')
 145  *        .action(function(dir, otherDirs) {
 146  *          console.log('dir "%s"', dir);
 147  *          if (otherDirs) {
 148  *            otherDirs.forEach(function (oDir) {
 149  *              console.log('dir "%s"', oDir);
 150  *            });
 151  *          }
 152  *        });
 153  *
 154  *      program
 155  *        .command('*')
 156  *        .description('deploy the given env')
 157  *        .action(function(env) {
 158  *          console.log('deploying "%s"', env);
 159  *        });
 160  *
 161  *      program.parse(process.argv);
 162   *
 163  * @param {String} name
 164  * @param {String} [desc] for git-style sub-commands
 165  * @return {Command} the new command
 166  * @api public
 167  */
 168
 169 Command.prototype.command = function(name, desc, opts) {
 170   if (typeof desc === 'object' && desc !== null) {
 171     opts = desc;
 172     desc = null;
 173   }
 174   opts = opts || {};
 175   var args = name.split(/ +/);
 176   var cmd = new Command(args.shift());
 177
 178   if (desc) {
 179     cmd.description(desc);
 180     this.executables = true;
 181     this._execs[cmd._name] = true;
 182     if (opts.isDefault) this.defaultExecutable = cmd._name;
 183   }
 184   cmd._noHelp = !!opts.noHelp;
 185   this.commands.push(cmd);
 186   cmd.parseExpectedArgs(args);
 187   cmd.parent = this;
 188
 189   if (desc) return this;
 190   return cmd;
 191 };
 192
 193 /**
 194  * Define argument syntax for the top-level command.
 195  *
 196  * @api public
 197  */
 198
 199 Command.prototype.arguments = function(desc) {
 200   return this.parseExpectedArgs(desc.split(/ +/));
 201 };
 202
 203 /**
 204  * Add an implicit `help [cmd]` subcommand
 205  * which invokes `--help` for the given command.
 206  *
 207  * @api private
 208  */
 209
 210 Command.prototype.addImplicitHelpCommand = function() {
 211   this.command('help [cmd]', 'display help for [cmd]');
 212 };
 213
 214 /**
 215  * Parse expected `args`.
 216  *
 217  * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
 218  *
 219  * @param {Array} args
 220  * @return {Command} for chaining
 221  * @api public
 222  */
 223
 224 Command.prototype.parseExpectedArgs = function(args) {
 225   if (!args.length) return;
 226   var self = this;
 227   args.forEach(function(arg) {
 228     var argDetails = {
 229       required: false,
 230       name: '',
 231       variadic: false
 232     };
 233
 234     switch (arg[0]) {
 235       case '<':
 236         argDetails.required = true;
 237         argDetails.name = arg.slice(1, -1);
 238         break;
 239       case '[':
 240         argDetails.name = arg.slice(1, -1);
 241         break;
 242     }
 243
 244     if (argDetails.name.length > 3 && argDetails.name.slice(-3) === '...') {
 245       argDetails.variadic = true;
 246       argDetails.name = argDetails.name.slice(0, -3);
 247     }
 248     if (argDetails.name) {
 249       self._args.push(argDetails);
 250     }
 251   });
 252   return this;
 253 };
 254
 255 /**
 256  * Register callback `fn` for the command.
 257  *
 258  * Examples:
 259  *
 260  *      program
 261  *        .command('help')
 262  *        .description('display verbose help')
 263  *        .action(function() {
 264  *           // output help here
 265  *        });
 266  *
 267  * @param {Function} fn
 268  * @return {Command} for chaining
 269  * @api public
 270  */
 271
 272 Command.prototype.action = function(fn) {
 273   var self = this;
 274   var listener = function(args, unknown) {
 275     // Parse any so-far unknown options
 276     args = args || [];
 277     unknown = unknown || [];
 278
 279     var parsed = self.parseOptions(unknown);
 280
 281     // Output help if necessary
 282     outputHelpIfNecessary(self, parsed.unknown);
 283
 284     // If there are still any unknown options, then we simply
 285     // die, unless someone asked for help, in which case we give it
 286     // to them, and then we die.
 287     if (parsed.unknown.length > 0) {
 288       self.unknownOption(parsed.unknown[0]);
 289     }
 290
 291     // Leftover arguments need to be pushed back. Fixes issue #56
 292     if (parsed.args.length) args = parsed.args.concat(args);
 293
 294     self._args.forEach(function(arg, i) {
 295       if (arg.required && args[i] == null) {
 296         self.missingArgument(arg.name);
 297       } else if (arg.variadic) {
 298         if (i !== self._args.length - 1) {
 299           self.variadicArgNotLast(arg.name);
 300         }
 301
 302         args[i] = args.splice(i);
 303       }
 304     });
 305
 306     // Always append ourselves to the end of the arguments,
 307     // to make sure we match the number of arguments the user
 308     // expects
 309     if (self._args.length) {
 310       args[self._args.length] = self;
 311     } else {
 312       args.push(self);
 313     }
 314
 315     fn.apply(self, args);
 316   };
 317   var parent = this.parent || this;
 318   var name = parent === this ? '*' : this._name;
 319   parent.on('command:' + name, listener);
 320   if (this._alias) parent.on('command:' + this._alias, listener);
 321   return this;
 322 };
 323
 324 /**
 325  * Define option with `flags`, `description` and optional
 326  * coercion `fn`.
 327  *
 328  * The `flags` string should contain both the short and long flags,
 329  * separated by comma, a pipe or space. The following are all valid
 330  * all will output this way when `--help` is used.
 331  *
 332  *    "-p, --pepper"
 333  *    "-p|--pepper"
 334  *    "-p --pepper"
 335  *
 336  * Examples:
 337  *
 338  *     // simple boolean defaulting to false
 339  *     program.option('-p, --pepper', 'add pepper');
 340  *
 341  *     --pepper
 342  *     program.pepper
 343  *     // => Boolean
 344  *
 345  *     // simple boolean defaulting to true
 346  *     program.option('-C, --no-cheese', 'remove cheese');
 347  *
 348  *     program.cheese
 349  *     // => true
 350  *
 351  *     --no-cheese
 352  *     program.cheese
 353  *     // => false
 354  *
 355  *     // required argument
 356  *     program.option('-C, --chdir <path>', 'change the working directory');
 357  *
 358  *     --chdir /tmp
 359  *     program.chdir
 360  *     // => "/tmp"
 361  *
 362  *     // optional argument
 363  *     program.option('-c, --cheese [type]', 'add cheese [marble]');
 364  *
 365  * @param {String} flags
 366  * @param {String} description
 367  * @param {Function|*} [fn] or default
 368  * @param {*} [defaultValue]
 369  * @return {Command} for chaining
 370  * @api public
 371  */
 372
 373 Command.prototype.option = function(flags, description, fn, defaultValue) {
 374   var self = this,
 375     option = new Option(flags, description),
 376     oname = option.name(),
 377     name = option.attributeName();
 378
 379   // default as 3rd arg
 380   if (typeof fn !== 'function') {
 381     if (fn instanceof RegExp) {
 382       var regex = fn;
 383       fn = function(val, def) {
 384         var m = regex.exec(val);
 385         return m ? m[0] : def;
 386       };
 387     } else {
 388       defaultValue = fn;
 389       fn = null;
 390     }
 391   }
 392
 393   // preassign default value only for --no-*, [optional], or <required>
 394   if (!option.bool || option.optional || option.required) {
 395     // when --no-* we make sure default is true
 396     if (!option.bool) defaultValue = true;
 397     // preassign only if we have a default
 398     if (defaultValue !== undefined) {
 399       self[name] = defaultValue;
 400       option.defaultValue = defaultValue;
 401     }
 402   }
 403
 404   // register the option
 405   this.options.push(option);
 406
 407   // when it's passed assign the value
 408   // and conditionally invoke the callback
 409   this.on('option:' + oname, function(val) {
 410     // coercion
 411     if (val !== null && fn) {
 412       val = fn(val, self[name] === undefined ? defaultValue : self[name]);
 413     }
 414
 415     // unassigned or bool
 416     if (typeof self[name] === 'boolean' || typeof self[name] === 'undefined') {
 417       // if no value, bool true, and we have a default, then use it!
 418       if (val == null) {
 419         self[name] = option.bool
 420           ? defaultValue || true
 421           : false;
 422       } else {
 423         self[name] = val;
 424       }
 425     } else if (val !== null) {
 426       // reassign
 427       self[name] = val;
 428     }
 429   });
 430
 431   return this;
 432 };
 433
 434 /**
 435  * Allow unknown options on the command line.
 436  *
 437  * @param {Boolean} arg if `true` or omitted, no error will be thrown
 438  * for unknown options.
 439  * @api public
 440  */
 441 Command.prototype.allowUnknownOption = function(arg) {
 442   this._allowUnknownOption = arguments.length === 0 || arg;
 443   return this;
 444 };
 445
 446 /**
 447  * Parse `argv`, settings options and invoking commands when defined.
 448  *
 449  * @param {Array} argv
 450  * @return {Command} for chaining
 451  * @api public
 452  */
 453
 454 Command.prototype.parse = function(argv) {
 455   // implicit help
 456   if (this.executables) this.addImplicitHelpCommand();
 457
 458   // store raw args
 459   this.rawArgs = argv;
 460
 461   // guess name
 462   this._name = this._name || basename(argv[1], '.js');
 463
 464   // github-style sub-commands with no sub-command
 465   if (this.executables && argv.length < 3 && !this.defaultExecutable) {
 466     // this user needs help
 467     argv.push('--help');
 468   }
 469
 470   // process argv
 471   var parsed = this.parseOptions(this.normalize(argv.slice(2)));
 472   var args = this.args = parsed.args;
 473
 474   var result = this.parseArgs(this.args, parsed.unknown);
 475
 476   // executable sub-commands
 477   var name = result.args[0];
 478
 479   var aliasCommand = null;
 480   // check alias of sub commands
 481   if (name) {
 482     aliasCommand = this.commands.filter(function(command) {
 483       return command.alias() === name;
 484     })[0];
 485   }
 486
 487   if (this._execs[name] && typeof this._execs[name] !== 'function') {
 488     return this.executeSubCommand(argv, args, parsed.unknown);
 489   } else if (aliasCommand) {
 490     // is alias of a subCommand
 491     args[0] = aliasCommand._name;
 492     return this.executeSubCommand(argv, args, parsed.unknown);
 493   } else if (this.defaultExecutable) {
 494     // use the default subcommand
 495     args.unshift(this.defaultExecutable);
 496     return this.executeSubCommand(argv, args, parsed.unknown);
 497   }
 498
 499   return result;
 500 };
 501
 502 /**
 503  * Execute a sub-command executable.
 504  *
 505  * @param {Array} argv
 506  * @param {Array} args
 507  * @param {Array} unknown
 508  * @api private
 509  */
 510
 511 Command.prototype.executeSubCommand = function(argv, args, unknown) {
 512   args = args.concat(unknown);
 513
 514   if (!args.length) this.help();
 515   if (args[0] === 'help' && args.length === 1) this.help();
 516
 517   // <cmd> --help
 518   if (args[0] === 'help') {
 519     args[0] = args[1];
 520     args[1] = '--help';
 521   }
 522
 523   // executable
 524   var f = argv[1];
 525   // name of the subcommand, link `pm-install`
 526   var bin = basename(f, '.js') + '-' + args[0];
 527
 528   // In case of globally installed, get the base dir where executable
 529   //  subcommand file should be located at
 530   var baseDir,
 531     link = fs.lstatSync(f).isSymbolicLink() ? fs.readlinkSync(f) : f;
 532
 533   // when symbolink is relative path
 534   if (link !== f && link.charAt(0) !== '/') {
 535     link = path.join(dirname(f), link);
 536   }
 537   baseDir = dirname(link);
 538
 539   // prefer local `./<bin>` to bin in the $PATH
 540   var localBin = path.join(baseDir, bin);
 541
 542   // whether bin file is a js script with explicit `.js` extension
 543   var isExplicitJS = false;
 544   if (exists(localBin + '.js')) {
 545     bin = localBin + '.js';
 546     isExplicitJS = true;
 547   } else if (exists(localBin)) {
 548     bin = localBin;
 549   }
 550
 551   args = args.slice(1);
 552
 553   var proc;
 554   if (process.platform !== 'win32') {
 555     if (isExplicitJS) {
 556       args.unshift(bin);
 557       // add executable arguments to spawn
 558       args = (process.execArgv || []).concat(args);
 559
 560       proc = spawn(process.argv[0], args, { stdio: 'inherit', customFds: [0, 1, 2] });
 561     } else {
 562       proc = spawn(bin, args, { stdio: 'inherit', customFds: [0, 1, 2] });
 563     }
 564   } else {
 565     args.unshift(bin);
 566     proc = spawn(process.execPath, args, { stdio: 'inherit' });
 567   }
 568
 569   var signals = ['SIGUSR1', 'SIGUSR2', 'SIGTERM', 'SIGINT', 'SIGHUP'];
 570   signals.forEach(function(signal) {
 571     process.on(signal, function() {
 572       if (proc.killed === false && proc.exitCode === null) {
 573         proc.kill(signal);
 574       }
 575     });
 576   });
 577   proc.on('close', process.exit.bind(process));
 578   proc.on('error', function(err) {
 579     if (err.code === 'ENOENT') {
 580       console.error('\n  %s(1) does not exist, try --help\n', bin);
 581     } else if (err.code === 'EACCES') {
 582       console.error('\n  %s(1) not executable. try chmod or run with root\n', bin);
 583     }
 584     process.exit(1);
 585   });
 586
 587   // Store the reference to the child process
 588   this.runningCommand = proc;
 589 };
 590
 591 /**
 592  * Normalize `args`, splitting joined short flags. For example
 593  * the arg "-abc" is equivalent to "-a -b -c".
 594  * This also normalizes equal sign and splits "--abc=def" into "--abc def".
 595  *
 596  * @param {Array} args
 597  * @return {Array}
 598  * @api private
 599  */
 600
 601 Command.prototype.normalize = function(args) {
 602   var ret = [],
 603     arg,
 604     lastOpt,
 605     index;
 606
 607   for (var i = 0, len = args.length; i < len; ++i) {
 608     arg = args[i];
 609     if (i > 0) {
 610       lastOpt = this.optionFor(args[i - 1]);
 611     }
 612
 613     if (arg === '--') {
 614       // Honor option terminator
 615       ret = ret.concat(args.slice(i));
 616       break;
 617     } else if (lastOpt && lastOpt.required) {
 618       ret.push(arg);
 619     } else if (arg.length > 1 && arg[0] === '-' && arg[1] !== '-') {
 620       arg.slice(1).split('').forEach(function(c) {
 621         ret.push('-' + c);
 622       });
 623     } else if (/^--/.test(arg) && ~(index = arg.indexOf('='))) {
 624       ret.push(arg.slice(0, index), arg.slice(index + 1));
 625     } else {
 626       ret.push(arg);
 627     }
 628   }
 629
 630   return ret;
 631 };
 632
 633 /**
 634  * Parse command `args`.
 635  *
 636  * When listener(s) are available those
 637  * callbacks are invoked, otherwise the "*"
 638  * event is emitted and those actions are invoked.
 639  *
 640  * @param {Array} args
 641  * @return {Command} for chaining
 642  * @api private
 643  */
 644
 645 Command.prototype.parseArgs = function(args, unknown) {
 646   var name;
 647
 648   if (args.length) {
 649     name = args[0];
 650     if (this.listeners('command:' + name).length) {
 651       this.emit('command:' + args.shift(), args, unknown);
 652     } else {
 653       this.emit('command:*', args);
 654     }
 655   } else {
 656     outputHelpIfNecessary(this, unknown);
 657
 658     // If there were no args and we have unknown options,
 659     // then they are extraneous and we need to error.
 660     if (unknown.length > 0) {
 661       this.unknownOption(unknown[0]);
 662     }
 663   }
 664
 665   return this;
 666 };
 667
 668 /**
 669  * Return an option matching `arg` if any.
 670  *
 671  * @param {String} arg
 672  * @return {Option}
 673  * @api private
 674  */
 675
 676 Command.prototype.optionFor = function(arg) {
 677   for (var i = 0, len = this.options.length; i < len; ++i) {
 678     if (this.options[i].is(arg)) {
 679       return this.options[i];
 680     }
 681   }
 682 };
 683
 684 /**
 685  * Parse options from `argv` returning `argv`
 686  * void of these options.
 687  *
 688  * @param {Array} argv
 689  * @return {Array}
 690  * @api public
 691  */
 692
 693 Command.prototype.parseOptions = function(argv) {
 694   var args = [],
 695     len = argv.length,
 696     literal,
 697     option,
 698     arg;
 699
 700   var unknownOptions = [];
 701
 702   // parse options
 703   for (var i = 0; i < len; ++i) {
 704     arg = argv[i];
 705
 706     // literal args after --
 707     if (literal) {
 708       args.push(arg);
 709       continue;
 710     }
 711
 712     if (arg === '--') {
 713       literal = true;
 714       continue;
 715     }
 716
 717     // find matching Option
 718     option = this.optionFor(arg);
 719
 720     // option is defined
 721     if (option) {
 722       // requires arg
 723       if (option.required) {
 724         arg = argv[++i];
 725         if (arg == null) return this.optionMissingArgument(option);
 726         this.emit('option:' + option.name(), arg);
 727       // optional arg
 728       } else if (option.optional) {
 729         arg = argv[i + 1];
 730         if (arg == null || (arg[0] === '-' && arg !== '-')) {
 731           arg = null;
 732         } else {
 733           ++i;
 734         }
 735         this.emit('option:' + option.name(), arg);
 736       // bool
 737       } else {
 738         this.emit('option:' + option.name());
 739       }
 740       continue;
 741     }
 742
 743     // looks like an option
 744     if (arg.length > 1 && arg[0] === '-') {
 745       unknownOptions.push(arg);
 746
 747       // If the next argument looks like it might be
 748       // an argument for this option, we pass it on.
 749       // If it isn't, then it'll simply be ignored
 750       if ((i + 1) < argv.length && argv[i + 1][0] !== '-') {
 751         unknownOptions.push(argv[++i]);
 752       }
 753       continue;
 754     }
 755
 756     // arg
 757     args.push(arg);
 758   }
 759
 760   return { args: args, unknown: unknownOptions };
 761 };
 762
 763 /**
 764  * Return an object containing options as key-value pairs
 765  *
 766  * @return {Object}
 767  * @api public
 768  */
 769 Command.prototype.opts = function() {
 770   var result = {},
 771     len = this.options.length;
 772
 773   for (var i = 0; i < len; i++) {
 774     var key = this.options[i].attributeName();
 775     result[key] = key === this._versionOptionName ? this._version : this[key];
 776   }
 777   return result;
 778 };
 779
 780 /**
 781  * Argument `name` is missing.
 782  *
 783  * @param {String} name
 784  * @api private
 785  */
 786
 787 Command.prototype.missingArgument = function(name) {
 788   console.error();
 789   console.error("  error: missing required argument `%s'", name);
 790   console.error();
 791   process.exit(1);
 792 };
 793
 794 /**
 795  * `Option` is missing an argument, but received `flag` or nothing.
 796  *
 797  * @param {String} option
 798  * @param {String} flag
 799  * @api private
 800  */
 801
 802 Command.prototype.optionMissingArgument = function(option, flag) {
 803   console.error();
 804   if (flag) {
 805     console.error("  error: option `%s' argument missing, got `%s'", option.flags, flag);
 806   } else {
 807     console.error("  error: option `%s' argument missing", option.flags);
 808   }
 809   console.error();
 810   process.exit(1);
 811 };
 812
 813 /**
 814  * Unknown option `flag`.
 815  *
 816  * @param {String} flag
 817  * @api private
 818  */
 819
 820 Command.prototype.unknownOption = function(flag) {
 821   if (this._allowUnknownOption) return;
 822   console.error();
 823   console.error("  error: unknown option `%s'", flag);
 824   console.error();
 825   process.exit(1);
 826 };
 827
 828 /**
 829  * Variadic argument with `name` is not the last argument as required.
 830  *
 831  * @param {String} name
 832  * @api private
 833  */
 834
 835 Command.prototype.variadicArgNotLast = function(name) {
 836   console.error();
 837   console.error("  error: variadic arguments must be last `%s'", name);
 838   console.error();
 839   process.exit(1);
 840 };
 841
 842 /**
 843  * Set the program version to `str`.
 844  *
 845  * This method auto-registers the "-V, --version" flag
 846  * which will print the version number when passed.
 847  *
 848  * @param {String} str
 849  * @param {String} [flags]
 850  * @return {Command} for chaining
 851  * @api public
 852  */
 853
 854 Command.prototype.version = function(str, flags) {
 855   if (arguments.length === 0) return this._version;
 856   this._version = str;
 857   flags = flags || '-V, --version';
 858   var versionOption = new Option(flags, 'output the version number');
 859   this._versionOptionName = versionOption.long.substr(2) || 'version';
 860   this.options.push(versionOption);
 861   this.on('option:' + this._versionOptionName, function() {
 862     process.stdout.write(str + '\n');
 863     process.exit(0);
 864   });
 865   return this;
 866 };
 867
 868 /**
 869  * Set the description to `str`.
 870  *
 871  * @param {String} str
 872  * @param {Object} argsDescription
 873  * @return {String|Command}
 874  * @api public
 875  */
 876
 877 Command.prototype.description = function(str, argsDescription) {
 878   if (arguments.length === 0) return this._description;
 879   this._description = str;
 880   this._argsDescription = argsDescription;
 881   return this;
 882 };
 883
 884 /**
 885  * Set an alias for the command
 886  *
 887  * @param {String} alias
 888  * @return {String|Command}
 889  * @api public
 890  */
 891
 892 Command.prototype.alias = function(alias) {
 893   var command = this;
 894   if (this.commands.length !== 0) {
 895     command = this.commands[this.commands.length - 1];
 896   }
 897
 898   if (arguments.length === 0) return command._alias;
 899
 900   if (alias === command._name) throw new Error('Command alias can\'t be the same as its name');
 901
 902   command._alias = alias;
 903   return this;
 904 };
 905
 906 /**
 907  * Set / get the command usage `str`.
 908  *
 909  * @param {String} str
 910  * @return {String|Command}
 911  * @api public
 912  */
 913
 914 Command.prototype.usage = function(str) {
 915   var args = this._args.map(function(arg) {
 916     return humanReadableArgName(arg);
 917   });
 918
 919   var usage = '[options]' +
 920     (this.commands.length ? ' [command]' : '') +
 921     (this._args.length ? ' ' + args.join(' ') : '');
 922
 923   if (arguments.length === 0) return this._usage || usage;
 924   this._usage = str;
 925
 926   return this;
 927 };
 928
 929 /**
 930  * Get or set the name of the command
 931  *
 932  * @param {String} str
 933  * @return {String|Command}
 934  * @api public
 935  */
 936
 937 Command.prototype.name = function(str) {
 938   if (arguments.length === 0) return this._name;
 939   this._name = str;
 940   return this;
 941 };
 942
 943 /**
 944  * Return prepared commands.
 945  *
 946  * @return {Array}
 947  * @api private
 948  */
 949
 950 Command.prototype.prepareCommands = function() {
 951   return this.commands.filter(function(cmd) {
 952     return !cmd._noHelp;
 953   }).map(function(cmd) {
 954     var args = cmd._args.map(function(arg) {
 955       return humanReadableArgName(arg);
 956     }).join(' ');
 957
 958     return [
 959       cmd._name +
 960         (cmd._alias ? '|' + cmd._alias : '') +
 961         (cmd.options.length ? ' [options]' : '') +
 962         (args ? ' ' + args : ''),
 963       cmd._description
 964     ];
 965   });
 966 };
 967
 968 /**
 969  * Return the largest command length.
 970  *
 971  * @return {Number}
 972  * @api private
 973  */
 974
 975 Command.prototype.largestCommandLength = function() {
 976   var commands = this.prepareCommands();
 977   return commands.reduce(function(max, command) {
 978     return Math.max(max, command[0].length);
 979   }, 0);
 980 };
 981
 982 /**
 983  * Return the largest option length.
 984  *
 985  * @return {Number}
 986  * @api private
 987  */
 988
 989 Command.prototype.largestOptionLength = function() {
 990   var options = [].slice.call(this.options);
 991   options.push({
 992     flags: '-h, --help'
 993   });
 994   return options.reduce(function(max, option) {
 995     return Math.max(max, option.flags.length);
 996   }, 0);
 997 };
 998
 999 /**
1000  * Return the largest arg length.
1001  *
1002  * @return {Number}
1003  * @api private
1004  */
1005
1006 Command.prototype.largestArgLength = function() {
1007   return this._args.reduce(function(max, arg) {
1008     return Math.max(max, arg.name.length);
1009   }, 0);
1010 };
1011
1012 /**
1013  * Return the pad width.
1014  *
1015  * @return {Number}
1016  * @api private
1017  */
1018
1019 Command.prototype.padWidth = function() {
1020   var width = this.largestOptionLength();
1021   if (this._argsDescription && this._args.length) {
1022     if (this.largestArgLength() > width) {
1023       width = this.largestArgLength();
1024     }
1025   }
1026
1027   if (this.commands && this.commands.length) {
1028     if (this.largestCommandLength() > width) {
1029       width = this.largestCommandLength();
1030     }
1031   }
1032
1033   return width;
1034 };
1035
1036 /**
1037  * Return help for options.
1038  *
1039  * @return {String}
1040  * @api private
1041  */
1042
1043 Command.prototype.optionHelp = function() {
1044   var width = this.padWidth();
1045
1046   // Append the help information
1047   return this.options.map(function(option) {
1048     return pad(option.flags, width) + '  ' + option.description +
1049       ((option.bool && option.defaultValue !== undefined) ? ' (default: ' + option.defaultValue + ')' : '');
1050   }).concat([pad('-h, --help', width) + '  ' + 'output usage information'])
1051     .join('\n');
1052 };
1053
1054 /**
1055  * Return command help documentation.
1056  *
1057  * @return {String}
1058  * @api private
1059  */
1060
1061 Command.prototype.commandHelp = function() {
1062   if (!this.commands.length) return '';
1063
1064   var commands = this.prepareCommands();
1065   var width = this.padWidth();
1066
1067   return [
1068     '  Commands:',
1069     '',
1070     commands.map(function(cmd) {
1071       var desc = cmd[1] ? '  ' + cmd[1] : '';
1072       return (desc ? pad(cmd[0], width) : cmd[0]) + desc;
1073     }).join('\n').replace(/^/gm, '    '),
1074     ''
1075   ].join('\n');
1076 };
1077
1078 /**
1079  * Return program help documentation.
1080  *
1081  * @return {String}
1082  * @api private
1083  */
1084
1085 Command.prototype.helpInformation = function() {
1086   var desc = [];
1087   if (this._description) {
1088     desc = [
1089       '  ' + this._description,
1090       ''
1091     ];
1092
1093     var argsDescription = this._argsDescription;
1094     if (argsDescription && this._args.length) {
1095       var width = this.padWidth();
1096       desc.push('  Arguments:');
1097       desc.push('');
1098       this._args.forEach(function(arg) {
1099         desc.push('    ' + pad(arg.name, width) + '  ' + argsDescription[arg.name]);
1100       });
1101       desc.push('');
1102     }
1103   }
1104
1105   var cmdName = this._name;
1106   if (this._alias) {
1107     cmdName = cmdName + '|' + this._alias;
1108   }
1109   var usage = [
1110     '',
1111     '  Usage: ' + cmdName + ' ' + this.usage(),
1112     ''
1113   ];
1114
1115   var cmds = [];
1116   var commandHelp = this.commandHelp();
1117   if (commandHelp) cmds = [commandHelp];
1118
1119   var options = [
1120     '  Options:',
1121     '',
1122     '' + this.optionHelp().replace(/^/gm, '    '),
1123     ''
1124   ];
1125
1126   return usage
1127     .concat(desc)
1128     .concat(options)
1129     .concat(cmds)
1130     .join('\n');
1131 };
1132
1133 /**
1134  * Output help information for this command
1135  *
1136  * @api public
1137  */
1138
1139 Command.prototype.outputHelp = function(cb) {
1140   if (!cb) {
1141     cb = function(passthru) {
1142       return passthru;
1143     };
1144   }
1145   process.stdout.write(cb(this.helpInformation()));
1146   this.emit('--help');
1147 };
1148
1149 /**
1150  * Output help information and exit.
1151  *
1152  * @api public
1153  */
1154
1155 Command.prototype.help = function(cb) {
1156   this.outputHelp(cb);
1157   process.exit();
1158 };
1159
1160 /**
1161  * Camel-case the given `flag`
1162  *
1163  * @param {String} flag
1164  * @return {String}
1165  * @api private
1166  */
1167
1168 function camelcase(flag) {
1169   return flag.split('-').reduce(function(str, word) {
1170     return str + word[0].toUpperCase() + word.slice(1);
1171   });
1172 }
1173
1174 /**
1175  * Pad `str` to `width`.
1176  *
1177  * @param {String} str
1178  * @param {Number} width
1179  * @return {String}
1180  * @api private
1181  */
1182
1183 function pad(str, width) {
1184   var len = Math.max(0, width - str.length);
1185   return str + Array(len + 1).join(' ');
1186 }
1187
1188 /**
1189  * Output help information if necessary
1190  *
1191  * @param {Command} command to output help for
1192  * @param {Array} array of options to search for -h or --help
1193  * @api private
1194  */
1195
1196 function outputHelpIfNecessary(cmd, options) {
1197   options = options || [];
1198   for (var i = 0; i < options.length; i++) {
1199     if (options[i] === '--help' || options[i] === '-h') {
1200       cmd.outputHelp();
1201       process.exit(0);
1202     }
1203   }
1204 }
1205
1206 /**
1207  * Takes an argument an returns its human readable equivalent for help usage.
1208  *
1209  * @param {Object} arg
1210  * @return {String}
1211  * @api private
1212  */
1213
1214 function humanReadableArgName(arg) {
1215   var nameOutput = arg.name + (arg.variadic === true ? '...' : '');
1216
1217   return arg.required
1218     ? '<' + nameOutput + '>'
1219     : '[' + nameOutput + ']';
1220 }
1221
1222 // for versions before node v0.8 when there weren't `fs.existsSync`
1223 function exists(file) {
1224   try {
1225     if (fs.statSync(file).isFile()) {
1226       return true;
1227     }
1228   } catch (e) {
1229     return false;
1230   }
1231 }