pax_global_header00006660000000000000000000000064124202201150014477gustar00rootroot0000000000000052 comment=db67c895df167682112e3a523de8d23b0a5ee543 commander.js-2.4.0/000077500000000000000000000000001242022011500140625ustar00rootroot00000000000000commander.js-2.4.0/.gitignore000066400000000000000000000000441242022011500160500ustar00rootroot00000000000000.DS_Store node_modules *.sock .idea commander.js-2.4.0/.travis.yml000066400000000000000000000000721242022011500161720ustar00rootroot00000000000000language: node_js node_js: - "0.6" - "0.8" - "0.10" commander.js-2.4.0/History.md000066400000000000000000000106501242022011500160470ustar00rootroot000000000000002.4.0 / 2014-10-17 ================== * Fixed a bug on executing the coercion function of subcommands option. Closes #270 * added `Command.prototype.name` to retrieve command name. Closes #264 #266 @tonylukasavage * added `Command.prototype.opts` to retrieve all the options as a simple object of key-value pairs. Closes #262 @tonylukasavage * Fixed a bug on subcommand name. Closes #248 @jonathandelgado * Fixed function normalize doesn’t honor option terminator. Closes #216 @abbr 2.3.0 / 2014-07-16 ================== * add command alias'. Closes PR #210 * fix: Typos. Closes #99 * fix: Unused fs module. Closes #217 2.2.0 / 2014-03-29 ================== * add passing of previous option value * fix: support subcommands on windows. Closes #142 2.1.0 / 2013-11-21 ================== * add: allow cflag style option params, unit test, fixes #174 2.0.0 / 2013-07-18 ================== * remove input methods (.prompt, .confirm, etc) 1.3.2 / 2013-07-18 ================== * add support for sub-commands to co-exist with the original command 1.3.1 / 2013-07-18 ================== * add quick .runningCommand hack so you can opt-out of other logic when running a sub command 1.3.0 / 2013-07-09 ================== * add EACCES error handling * fix sub-command --help 1.2.0 / 2013-06-13 ================== * allow "-" hyphen as an option argument * support for RegExp coercion 1.1.1 / 2012-11-20 ================== * add more sub-command padding * fix .usage() when args are present. Closes #106 1.1.0 / 2012-11-16 ================== * add git-style executable subcommand support. Closes #94 1.0.5 / 2012-10-09 ================== * fix `--name` clobbering. Closes #92 * fix examples/help. Closes #89 1.0.4 / 2012-09-03 ================== * add `outputHelp()` method. 1.0.3 / 2012-08-30 ================== * remove invalid .version() defaulting 1.0.2 / 2012-08-24 ================== * add `--foo=bar` support [arv] * fix password on node 0.8.8. Make backward compatible with 0.6 [focusaurus] 1.0.1 / 2012-08-03 ================== * fix issue #56 * fix tty.setRawMode(mode) was moved to tty.ReadStream#setRawMode() (i.e. process.stdin.setRawMode()) 1.0.0 / 2012-07-05 ================== * add support for optional option descriptions * add defaulting of `.version()` to package.json's version 0.6.1 / 2012-06-01 ================== * Added: append (yes or no) on confirmation * Added: allow node.js v0.7.x 0.6.0 / 2012-04-10 ================== * Added `.prompt(obj, callback)` support. Closes #49 * Added default support to .choose(). Closes #41 * Fixed the choice example 0.5.1 / 2011-12-20 ================== * Fixed `password()` for recent nodes. Closes #36 0.5.0 / 2011-12-04 ================== * Added sub-command option support [itay] 0.4.3 / 2011-12-04 ================== * Fixed custom help ordering. Closes #32 0.4.2 / 2011-11-24 ================== * Added travis support * Fixed: line-buffered input automatically trimmed. Closes #31 0.4.1 / 2011-11-18 ================== * Removed listening for "close" on --help 0.4.0 / 2011-11-15 ================== * Added support for `--`. Closes #24 0.3.3 / 2011-11-14 ================== * Fixed: wait for close event when writing help info [Jerry Hamlet] 0.3.2 / 2011-11-01 ================== * Fixed long flag definitions with values [felixge] 0.3.1 / 2011-10-31 ================== * Changed `--version` short flag to `-V` from `-v` * Changed `.version()` so it's configurable [felixge] 0.3.0 / 2011-10-31 ================== * Added support for long flags only. Closes #18 0.2.1 / 2011-10-24 ================== * "node": ">= 0.4.x < 0.7.0". Closes #20 0.2.0 / 2011-09-26 ================== * Allow for defaults that are not just boolean. Default peassignment only occurs for --no-*, optional, and required arguments. [Jim Isaacs] 0.1.0 / 2011-08-24 ================== * Added support for custom `--help` output 0.0.5 / 2011-08-18 ================== * Changed: when the user enters nothing prompt for password again * Fixed issue with passwords beginning with numbers [NuckChorris] 0.0.4 / 2011-08-15 ================== * Fixed `Commander#args` 0.0.3 / 2011-08-15 ================== * Added default option value support 0.0.2 / 2011-08-15 ================== * Added mask support to `Command#password(str[, mask], fn)` * Added `Command#password(str, fn)` 0.0.1 / 2010-01-03 ================== * Initial release commander.js-2.4.0/Makefile000066400000000000000000000001201242022011500155130ustar00rootroot00000000000000 TESTS = $(shell find test/test.*.js) test: @./test/run $(TESTS) .PHONY: testcommander.js-2.4.0/Readme.md000066400000000000000000000135071242022011500156070ustar00rootroot00000000000000# Commander.js The complete solution for [node.js](http://nodejs.org) command-line interfaces, inspired by Ruby's [commander](https://github.com/visionmedia/commander). [![Build Status](https://api.travis-ci.org/visionmedia/commander.js.svg)](http://travis-ci.org/visionmedia/commander.js) ## Installation $ npm install commander ## Option parsing Options with commander are defined with the `.option()` method, also serving as documentation for the options. The example below parses args and options from `process.argv`, leaving remaining args as the `program.args` array which were not consumed by options. ```js #!/usr/bin/env node /** * Module dependencies. */ var program = require('commander'); program .version('0.0.1') .option('-p, --peppers', 'Add peppers') .option('-P, --pineapple', 'Add pineapple') .option('-b, --bbq', 'Add bbq sauce') .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]', 'marble') .parse(process.argv); console.log('you ordered a pizza with:'); if (program.peppers) console.log(' - peppers'); if (program.pineapple) console.log(' - pineapple'); if (program.bbq) console.log(' - bbq'); console.log(' - %s cheese', program.cheese); ``` Short flags may be passed as a single arg, for example `-abc` is equivalent to `-a -b -c`. Multi-word options such as "--template-engine" are camel-cased, becoming `program.templateEngine` etc. ## Automated --help The help information is auto-generated based on the information commander already knows about your program, so the following `--help` info is for free: ``` $ ./examples/pizza --help Usage: pizza [options] Options: -V, --version output the version number -p, --peppers Add peppers -P, --pineapple Add pineapple -b, --bbq Add bbq sauce -c, --cheese Add the specified type of cheese [marble] -h, --help output usage information ``` ## Coercion ```js function range(val) { return val.split('..').map(Number); } function list(val) { return val.split(','); } function collect(val, memo) { memo.push(val); return memo; } function increaseVerbosity(v, total) { return total + 1; } program .version('0.0.1') .usage('[options] ') .option('-i, --integer ', 'An integer argument', parseInt) .option('-f, --float ', 'A float argument', parseFloat) .option('-r, --range ..', 'A range', range) .option('-l, --list ', 'A list', list) .option('-o, --optional [value]', 'An optional value') .option('-c, --collect [value]', 'A repeatable value', collect, []) .option('-v, --verbose', 'A value that can be increased', increaseVerbosity, 0) .parse(process.argv); console.log(' int: %j', program.integer); console.log(' float: %j', program.float); console.log(' optional: %j', program.optional); program.range = program.range || []; console.log(' range: %j..%j', program.range[0], program.range[1]); console.log(' list: %j', program.list); console.log(' collect: %j', program.collect); console.log(' verbosity: %j', program.verbose); console.log(' args: %j', program.args); ``` ## Custom help You can display arbitrary `-h, --help` information by listening for "--help". Commander will automatically exit once you are done so that the remainder of your program does not execute causing undesired behaviours, for example in the following executable "stuff" will not output when `--help` is used. ```js #!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); program .version('0.0.1') .option('-f, --foo', 'enable some foo') .option('-b, --bar', 'enable some bar') .option('-B, --baz', 'enable some baz'); // must be before .parse() since // node's emit() is immediate program.on('--help', function(){ console.log(' Examples:'); console.log(''); console.log(' $ custom-help --help'); console.log(' $ custom-help -h'); console.log(''); }); program.parse(process.argv); console.log('stuff'); ``` yielding the following help output: ``` Usage: custom-help [options] Options: -h, --help output usage information -V, --version output the version number -f, --foo enable some foo -b, --bar enable some bar -B, --baz enable some baz Examples: $ custom-help --help $ custom-help -h ``` ## .outputHelp() Output help information without exiting. ## .help() Output help information and exit immediately. ## Links - [API documentation](http://visionmedia.github.com/commander.js/) - [ascii tables](https://github.com/LearnBoost/cli-table) - [progress bars](https://github.com/visionmedia/node-progress) - [more progress bars](https://github.com/substack/node-multimeter) - [examples](https://github.com/visionmedia/commander.js/tree/master/examples) ## License (The MIT License) Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. commander.js-2.4.0/examples/000077500000000000000000000000001242022011500157005ustar00rootroot00000000000000commander.js-2.4.0/examples/coercion000077500000000000000000000023271242022011500174330ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); function range(val) { return val.split('..').map(Number); } function list(val) { return val.split(','); } function collect(val, memo) { memo.push(val); return memo; } function increaseVerbosity(v, total) { return total + 1; } program .version('0.0.1') .usage('test') .option('-i, --integer ', 'An integer argument', parseInt) .option('-f, --float ', 'A float argument', parseFloat) .option('-r, --range ..', 'A range', range) .option('-l, --list ', 'A list', list) .option('-o, --optional [value]', 'An optional value') .option('-c, --collect [value]', 'A repeatable value', collect, []) .option('-v, --verbose', 'A value that can be increased', increaseVerbosity, 0) .parse(process.argv); console.log(' int: %j', program.integer); console.log(' float: %j', program.float); console.log(' optional: %j', program.optional); program.range = program.range || []; console.log(' range: %j..%j', program.range[0], program.range[1]); console.log(' list: %j', program.list); console.log(' collect: %j', program.collect); console.log(' verbosity: %j', program.verbose); console.log(' args: %j', program.args); commander.js-2.4.0/examples/custom-help000077500000000000000000000010331242022011500200630ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); program .version('0.0.1') .option('-f, --foo', 'enable some foo') .option('-b, --bar', 'enable some bar') .option('-B, --baz', 'enable some baz'); // must be before .parse() since // node's emit() is immediate program.on('--help', function(){ console.log(' Examples:'); console.log(''); console.log(' $ custom-help --help'); console.log(' $ custom-help -h'); console.log(''); }); program.parse(process.argv); program.help(); commander.js-2.4.0/examples/defaults000077500000000000000000000011371242022011500174370ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); function list(val) { return val.split(',').map(Number); } program .version('0.0.1') .option('-t, --template-engine [engine]', 'Add template [engine] support', 'jade') .option('-c, --cheese [type]', 'Add the specified type of cheese [marble]', 'marble') .option('-l, --list [items]', 'Specify list items defaulting to 1,2,3', list, [1,2,3]) .parse(process.argv); console.log(' - %s template engine', program.templateEngine); console.log(' - %s cheese', program.cheese); console.log(' - %j', program.list); commander.js-2.4.0/examples/deploy000077500000000000000000000022761242022011500171310ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); program .version('0.0.1') .option('-C, --chdir ', 'change the working directory') .option('-c, --config ', 'set config path. defaults to ./deploy.conf') .option('-T, --no-tests', 'ignore test hook') program .command('setup [env]') .description('run setup commands for all envs') .option("-s, --setup_mode [mode]", "Which setup mode to use") .action(function(env, options){ var mode = options.setup_mode || "normal"; env = env || 'all'; console.log('setup for %s env(s) with %s mode', env, mode); }); program .command('exec ') .alias('ex') .description('execute the given remote cmd') .option("-e, --exec_mode ", "Which exec mode to use") .action(function(cmd, options){ console.log('exec "%s" using %s mode', cmd, options.exec_mode); }).on('--help', function() { console.log(' Examples:'); console.log(); console.log(' $ deploy exec sequential'); console.log(' $ deploy exec async'); console.log(); }); program .command('*') .action(function(env){ console.log('deploying "%s"', env); }); program.parse(process.argv); commander.js-2.4.0/examples/express000077500000000000000000000007741242022011500173270ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); program .version('0.0.1') .option('-s, --sessions', 'add session support') .option('-t, --template ', 'specify template engine (jade|ejs) [jade]', 'jade') .option('-c, --css ', 'specify stylesheet engine (stylus|sass|less) [css]', 'css') .parse(process.argv); console.log(' - sessions %j', program.sessions); console.log(' - template %j', program.template); console.log(' - css %j', program.css);commander.js-2.4.0/examples/help000077500000000000000000000004631242022011500165610ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); program .version('0.0.1') .option('-f, --foo', 'enable some foo') .option('-b, --bar', 'enable some bar') .option('-B, --baz', 'enable some baz') .parse(process.argv); if (!program.args.length) program.help(); commander.js-2.4.0/examples/pizza000077500000000000000000000013351242022011500167650ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); program .version('0.0.1') .option('-p, --peppers', 'Add peppers') .option('-P, --pineapple', 'Add pineapple') .option('-b, --bbq', 'Add bbq sauce') .option('-c, --cheese ', 'Add the specified type of cheese [marble]') .option('-C, --no-cheese', 'You do not want any cheese') .parse(process.argv); console.log('you ordered a pizza with:'); if (program.peppers) console.log(' - peppers'); if (program.pineapple) console.log(' - pineapple'); if (program.bbq) console.log(' - bbq'); var cheese = true === program.cheese ? 'marble' : program.cheese || 'no'; console.log(' - %s cheese', cheese); console.log(program.args); commander.js-2.4.0/examples/pm000077500000000000000000000014571242022011500162510ustar00rootroot00000000000000#!/usr/bin/env node var program = require('..'); program .version('0.0.1') .command('install [name]', 'install one or more packages') .command('search [query]', 'search with optional query') .command('list', 'list packages installed') .parse(process.argv); // here .command() is invoked with a description, // and no .action(callback) calls to handle sub-commands. // this tells commander that you're going to use separate // executables for sub-commands, much like git(1) and other // popular tools. // here only ./pm-install(1) is implemented, however you // would define ./pm-search(1) and ./pm-list(1) etc. // Try the following: // ./examples/pm // ./examples/pm help install // ./examples/pm install -h // ./examples/pm install foo bar baz // ./examples/pm install foo bar baz --force commander.js-2.4.0/examples/pm-install000077500000000000000000000006051242022011500177070ustar00rootroot00000000000000#!/usr/bin/env node var program = require('..'); program .option('-f, --force', 'force installation') .parse(process.argv); var pkgs = program.args; if (!pkgs.length) { console.error('packages required'); process.exit(1); } console.log(); if (program.force) console.log(' force: install'); pkgs.forEach(function(pkg){ console.log(' install : %s', pkg); }); console.log(); commander.js-2.4.0/index.js000066400000000000000000000472501242022011500155370ustar00rootroot00000000000000 /** * Module dependencies. */ var EventEmitter = require('events').EventEmitter; var spawn = require('child_process').spawn; var path = require('path'); var dirname = path.dirname; var basename = path.basename; /** * Expose the root command. */ exports = module.exports = new Command(); /** * Expose `Command`. */ exports.Command = Command; /** * Expose `Option`. */ exports.Option = Option; /** * Initialize a new `Option` with the given `flags` and `description`. * * @param {String} flags * @param {String} description * @api public */ function Option(flags, description) { this.flags = flags; this.required = ~flags.indexOf('<'); this.optional = ~flags.indexOf('['); this.bool = !~flags.indexOf('-no-'); flags = flags.split(/[ ,|]+/); if (flags.length > 1 && !/^[[<]/.test(flags[1])) this.short = flags.shift(); this.long = flags.shift(); this.description = description || ''; } /** * Return option name. * * @return {String} * @api private */ Option.prototype.name = function() { return this.long .replace('--', '') .replace('no-', ''); }; /** * Check if `arg` matches the short or long flag. * * @param {String} arg * @return {Boolean} * @api private */ Option.prototype.is = function(arg) { return arg == this.short || arg == this.long; }; /** * Initialize a new `Command`. * * @param {String} name * @api public */ function Command(name) { this.commands = []; this.options = []; this._execs = []; this._args = []; this._name = name; } /** * Inherit from `EventEmitter.prototype`. */ Command.prototype.__proto__ = EventEmitter.prototype; /** * Add command `name`. * * The `.action()` callback is invoked when the * command `name` is specified via __ARGV__, * and the remaining arguments are applied to the * function for access. * * When the `name` is "*" an un-matched command * will be passed as the first arg, followed by * the rest of __ARGV__ remaining. * * Examples: * * program * .version('0.0.1') * .option('-C, --chdir ', 'change the working directory') * .option('-c, --config ', 'set config path. defaults to ./deploy.conf') * .option('-T, --no-tests', 'ignore test hook') * * program * .command('setup') * .description('run remote setup commands') * .action(function() { * console.log('setup'); * }); * * program * .command('exec ') * .description('run the given remote command') * .action(function(cmd) { * console.log('exec "%s"', cmd); * }); * * program * .command('*') * .description('deploy the given env') * .action(function(env) { * console.log('deploying "%s"', env); * }); * * program.parse(process.argv); * * @param {String} name * @param {String} [desc] * @return {Command} the new command * @api public */ Command.prototype.command = function(name, desc) { var args = name.split(/ +/); var cmd = new Command(args.shift()); if (desc) cmd.description(desc); if (desc) this.executables = true; if (desc) this._execs[cmd._name] = true; this.commands.push(cmd); cmd.parseExpectedArgs(args); cmd.parent = this; if (desc) return this; return cmd; }; /** * Add an implicit `help [cmd]` subcommand * which invokes `--help` for the given command. * * @api private */ Command.prototype.addImplicitHelpCommand = function() { this.command('help [cmd]', 'display help for [cmd]'); }; /** * Parse expected `args`. * * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`. * * @param {Array} args * @return {Command} for chaining * @api public */ Command.prototype.parseExpectedArgs = function(args) { if (!args.length) return; var self = this; args.forEach(function(arg) { switch (arg[0]) { case '<': self._args.push({ required: true, name: arg.slice(1, -1) }); break; case '[': self._args.push({ required: false, name: arg.slice(1, -1) }); break; } }); return this; }; /** * Register callback `fn` for the command. * * Examples: * * program * .command('help') * .description('display verbose help') * .action(function() { * // output help here * }); * * @param {Function} fn * @return {Command} for chaining * @api public */ Command.prototype.action = function(fn) { var self = this; var listener = function(args, unknown) { // Parse any so-far unknown options args = args || []; unknown = unknown || []; var parsed = self.parseOptions(unknown); // Output help if necessary outputHelpIfNecessary(self, parsed.unknown); // If there are still any unknown options, then we simply // die, unless someone asked for help, in which case we give it // to them, and then we die. if (parsed.unknown.length > 0) { self.unknownOption(parsed.unknown[0]); } // Leftover arguments need to be pushed back. Fixes issue #56 if (parsed.args.length) args = parsed.args.concat(args); self._args.forEach(function(arg, i) { if (arg.required && null == args[i]) { self.missingArgument(arg.name); } }); // Always append ourselves to the end of the arguments, // to make sure we match the number of arguments the user // expects if (self._args.length) { args[self._args.length] = self; } else { args.push(self); } fn.apply(self, args); }; this.parent.on(this._name, listener); if (this._alias) this.parent.on(this._alias, listener); return this; }; /** * Define option with `flags`, `description` and optional * coercion `fn`. * * The `flags` string should contain both the short and long flags, * separated by comma, a pipe or space. The following are all valid * all will output this way when `--help` is used. * * "-p, --pepper" * "-p|--pepper" * "-p --pepper" * * Examples: * * // simple boolean defaulting to false * program.option('-p, --pepper', 'add pepper'); * * --pepper * program.pepper * // => Boolean * * // simple boolean defaulting to true * program.option('-C, --no-cheese', 'remove cheese'); * * program.cheese * // => true * * --no-cheese * program.cheese * // => false * * // required argument * program.option('-C, --chdir ', 'change the working directory'); * * --chdir /tmp * program.chdir * // => "/tmp" * * // optional argument * program.option('-c, --cheese [type]', 'add cheese [marble]'); * * @param {String} flags * @param {String} description * @param {Function|Mixed} fn or default * @param {Mixed} defaultValue * @return {Command} for chaining * @api public */ Command.prototype.option = function(flags, description, fn, defaultValue) { var self = this , option = new Option(flags, description) , oname = option.name() , name = camelcase(oname); // default as 3rd arg if (typeof fn != 'function') { defaultValue = fn; fn = null; } // preassign default value only for --no-*, [optional], or if (false == option.bool || option.optional || option.required) { // when --no-* we make sure default is true if (false == option.bool) defaultValue = true; // preassign only if we have a default if (undefined !== defaultValue) self[name] = defaultValue; } // register the option this.options.push(option); // when it's passed assign the value // and conditionally invoke the callback this.on(oname, function(val) { // coercion if (null !== val && fn) val = fn(val, undefined === self[name] ? defaultValue : self[name]); // unassigned or bool if ('boolean' == typeof self[name] || 'undefined' == typeof self[name]) { // if no value, bool true, and we have a default, then use it! if (null == val) { self[name] = option.bool ? defaultValue || true : false; } else { self[name] = val; } } else if (null !== val) { // reassign self[name] = val; } }); return this; }; /** * Parse `argv`, settings options and invoking commands when defined. * * @param {Array} argv * @return {Command} for chaining * @api public */ Command.prototype.parse = function(argv) { // implicit help if (this.executables) this.addImplicitHelpCommand(); // store raw args this.rawArgs = argv; // guess name this._name = this._name || basename(argv[1], '.js'); // process argv var parsed = this.parseOptions(this.normalize(argv.slice(2))); var args = this.args = parsed.args; var result = this.parseArgs(this.args, parsed.unknown); // executable sub-commands var name = result.args[0]; if (this._execs[name] && typeof this._execs[name] != "function") { return this.executeSubCommand(argv, args, parsed.unknown); } return result; }; /** * Execute a sub-command executable. * * @param {Array} argv * @param {Array} args * @param {Array} unknown * @api private */ Command.prototype.executeSubCommand = function(argv, args, unknown) { args = args.concat(unknown); if (!args.length) this.help(); if ('help' == args[0] && 1 == args.length) this.help(); // --help if ('help' == args[0]) { args[0] = args[1]; args[1] = '--help'; } // executable var dir = dirname(argv[1]); var bin = basename(argv[1], '.js') + '-' + args[0]; // check for ./ first var local = path.join(dir, bin); // run it args = args.slice(1); args.unshift(local); var proc = spawn('node', args, { stdio: 'inherit', customFds: [0, 1, 2] }); proc.on('error', function(err) { if (err.code == "ENOENT") { console.error('\n %s(1) does not exist, try --help\n', bin); } else if (err.code == "EACCES") { console.error('\n %s(1) not executable. try chmod or run with root\n', bin); } }); this.runningCommand = proc; }; /** * Normalize `args`, splitting joined short flags. For example * the arg "-abc" is equivalent to "-a -b -c". * This also normalizes equal sign and splits "--abc=def" into "--abc def". * * @param {Array} args * @return {Array} * @api private */ Command.prototype.normalize = function(args) { var ret = [] , arg , lastOpt , index; for (var i = 0, len = args.length; i < len; ++i) { arg = args[i]; if (i > 0) { lastOpt = this.optionFor(args[i-1]); } if (arg === '--') { // Honor option terminator ret = ret.concat(args.slice(i)); break; } else if (lastOpt && lastOpt.required) { ret.push(arg); } else if (arg.length > 1 && '-' == arg[0] && '-' != arg[1]) { arg.slice(1).split('').forEach(function(c) { ret.push('-' + c); }); } else if (/^--/.test(arg) && ~(index = arg.indexOf('='))) { ret.push(arg.slice(0, index), arg.slice(index + 1)); } else { ret.push(arg); } } return ret; }; /** * Parse command `args`. * * When listener(s) are available those * callbacks are invoked, otherwise the "*" * event is emitted and those actions are invoked. * * @param {Array} args * @return {Command} for chaining * @api private */ Command.prototype.parseArgs = function(args, unknown) { var name; if (args.length) { name = args[0]; if (this.listeners(name).length) { this.emit(args.shift(), args, unknown); } else { this.emit('*', args); } } else { outputHelpIfNecessary(this, unknown); // If there were no args and we have unknown options, // then they are extraneous and we need to error. if (unknown.length > 0) { this.unknownOption(unknown[0]); } } return this; }; /** * Return an option matching `arg` if any. * * @param {String} arg * @return {Option} * @api private */ Command.prototype.optionFor = function(arg) { for (var i = 0, len = this.options.length; i < len; ++i) { if (this.options[i].is(arg)) { return this.options[i]; } } }; /** * Parse options from `argv` returning `argv` * void of these options. * * @param {Array} argv * @return {Array} * @api public */ Command.prototype.parseOptions = function(argv) { var args = [] , len = argv.length , literal , option , arg; var unknownOptions = []; // parse options for (var i = 0; i < len; ++i) { arg = argv[i]; // literal args after -- if ('--' == arg) { literal = true; continue; } if (literal) { args.push(arg); continue; } // find matching Option option = this.optionFor(arg); // option is defined if (option) { // requires arg if (option.required) { arg = argv[++i]; if (null == arg) return this.optionMissingArgument(option); this.emit(option.name(), arg); // optional arg } else if (option.optional) { arg = argv[i+1]; if (null == arg || ('-' == arg[0] && '-' != arg)) { arg = null; } else { ++i; } this.emit(option.name(), arg); // bool } else { this.emit(option.name()); } continue; } // looks like an option if (arg.length > 1 && '-' == arg[0]) { unknownOptions.push(arg); // If the next argument looks like it might be // an argument for this option, we pass it on. // If it isn't, then it'll simply be ignored if (argv[i+1] && '-' != argv[i+1][0]) { unknownOptions.push(argv[++i]); } continue; } // arg args.push(arg); } return { args: args, unknown: unknownOptions }; }; /** * Return an object containing options as key-value pairs * * @return {Object} * @api public */ Command.prototype.opts = function() { var result = {} , len = this.options.length; for (var i = 0 ; i < len; i++) { var key = this.options[i].name(); result[key] = key === 'version' ? this._version : this[key]; } return result; }; /** * Argument `name` is missing. * * @param {String} name * @api private */ Command.prototype.missingArgument = function(name) { console.error(); console.error(" error: missing required argument `%s'", name); console.error(); process.exit(1); }; /** * `Option` is missing an argument, but received `flag` or nothing. * * @param {String} option * @param {String} flag * @api private */ Command.prototype.optionMissingArgument = function(option, flag) { console.error(); if (flag) { console.error(" error: option `%s' argument missing, got `%s'", option.flags, flag); } else { console.error(" error: option `%s' argument missing", option.flags); } console.error(); process.exit(1); }; /** * Unknown option `flag`. * * @param {String} flag * @api private */ Command.prototype.unknownOption = function(flag) { console.error(); console.error(" error: unknown option `%s'", flag); console.error(); process.exit(1); }; /** * Set the program version to `str`. * * This method auto-registers the "-V, --version" flag * which will print the version number when passed. * * @param {String} str * @param {String} flags * @return {Command} for chaining * @api public */ Command.prototype.version = function(str, flags) { if (0 == arguments.length) return this._version; this._version = str; flags = flags || '-V, --version'; this.option(flags, 'output the version number'); this.on('version', function() { process.stdout.write(str + '\n'); process.exit(0); }); return this; }; /** * Set the description to `str`. * * @param {String} str * @return {String|Command} * @api public */ Command.prototype.description = function(str) { if (0 == arguments.length) return this._description; this._description = str; return this; }; /** * Set an alias for the command * * @param {String} alias * @return {String|Command} * @api public */ Command.prototype.alias = function(alias) { if (0 == arguments.length) return this._alias; this._alias = alias; return this; }; /** * Set / get the command usage `str`. * * @param {String} str * @return {String|Command} * @api public */ Command.prototype.usage = function(str) { var args = this._args.map(function(arg) { return arg.required ? '<' + arg.name + '>' : '[' + arg.name + ']'; }); var usage = '[options]' + (this.commands.length ? ' [command]' : '') + (this._args.length ? ' ' + args.join(' ') : ''); if (0 == arguments.length) return this._usage || usage; this._usage = str; return this; }; /** * Get the name of the command * * @param {String} name * @return {String|Command} * @api public */ Command.prototype.name = function(name) { return this._name; }; /** * Return the largest option length. * * @return {Number} * @api private */ Command.prototype.largestOptionLength = function() { return this.options.reduce(function(max, option) { return Math.max(max, option.flags.length); }, 0); }; /** * Return help for options. * * @return {String} * @api private */ Command.prototype.optionHelp = function() { var width = this.largestOptionLength(); // Prepend the help information return [pad('-h, --help', width) + ' ' + 'output usage information'] .concat(this.options.map(function(option) { return pad(option.flags, width) + ' ' + option.description; })) .join('\n'); }; /** * Return command help documentation. * * @return {String} * @api private */ Command.prototype.commandHelp = function() { if (!this.commands.length) return ''; var commands = this.commands.map(function(cmd) { var args = cmd._args.map(function(arg) { return arg.required ? '<' + arg.name + '>' : '[' + arg.name + ']'; }).join(' '); return [ cmd._name + (cmd._alias ? '|' + cmd._alias : '') + (cmd.options.length ? ' [options]' : '') + ' ' + args , cmd.description() ]; }); var width = commands.reduce(function(max, command) { return Math.max(max, command[0].length); }, 0); return [ '' , ' Commands:' , '' , commands.map(function(cmd) { return pad(cmd[0], width) + ' ' + cmd[1]; }).join('\n').replace(/^/gm, ' ') , '' ].join('\n'); }; /** * Return program help documentation. * * @return {String} * @api private */ Command.prototype.helpInformation = function() { return [ '' , ' Usage: ' + this._name + (this._alias ? '|' + this._alias : '') + ' ' + this.usage() , '' + this.commandHelp() , ' Options:' , '' , '' + this.optionHelp().replace(/^/gm, ' ') , '' , '' ].join('\n'); }; /** * Output help information for this command * * @api public */ Command.prototype.outputHelp = function() { process.stdout.write(this.helpInformation()); this.emit('--help'); }; /** * Output help information and exit. * * @api public */ Command.prototype.help = function() { this.outputHelp(); process.exit(); }; /** * Camel-case the given `flag` * * @param {String} flag * @return {String} * @api private */ function camelcase(flag) { return flag.split('-').reduce(function(str, word) { return str + word[0].toUpperCase() + word.slice(1); }); } /** * Pad `str` to `width`. * * @param {String} str * @param {Number} width * @return {String} * @api private */ function pad(str, width) { var len = Math.max(0, width - str.length); return str + Array(len + 1).join(' '); } /** * Output help information if necessary * * @param {Command} command to output help for * @param {Array} array of options to search for -h or --help * @api private */ function outputHelpIfNecessary(cmd, options) { options = options || []; for (var i = 0; i < options.length; i++) { if (options[i] == '--help' || options[i] == '-h') { cmd.outputHelp(); process.exit(0); } } } commander.js-2.4.0/package.json000066400000000000000000000010141242022011500163440ustar00rootroot00000000000000{ "name": "commander" , "version": "2.4.0" , "description": "the complete solution for node.js command-line programs" , "keywords": ["command", "option", "parser", "prompt"] , "author": "TJ Holowaychuk " , "license": "MIT" , "repository": { "type": "git", "url": "https://github.com/visionmedia/commander.js.git" } , "devDependencies": { "should": ">= 0.0.1" } , "scripts": { "test": "make test" } , "main": "index" , "engines": { "node": ">= 0.6.x" } , "files": ["index.js"] } commander.js-2.4.0/test/000077500000000000000000000000001242022011500150415ustar00rootroot00000000000000commander.js-2.4.0/test/run000077500000000000000000000004271242022011500155760ustar00rootroot00000000000000#!/bin/sh export NODE_ENV=test echo for file in $@; do printf "\033[90m ${file#test/}\033[0m " node $file 2> /tmp/stderr && echo "\033[36m✓\033[0m" code=$? if test $code -ne 0; then echo "\033[31m✖\033[0m" cat /tmp/stderr >&2 exit $code fi done echocommander.js-2.4.0/test/test.command.action.js000066400000000000000000000004751242022011500212550ustar00rootroot00000000000000var program = require('../') , should = require('should'); var val = false; program .command('info [options]') .option('-C, --no-color', 'turn off color output') .action(function (){ val = this.color; }); program.parse(['node', 'test', 'info']); program.commands[0].color.should.equal(val); commander.js-2.4.0/test/test.command.name.js000066400000000000000000000005211242022011500207100ustar00rootroot00000000000000var program = require('../') , should = require('should'); program .command('mycommand [options]', 'this is my command'); program.parse(['node', 'test']); program.name.should.be.a.Function; program.name().should.equal('test'); program.commands[0].name().should.equal('mycommand'); program.commands[1].name().should.equal('help'); commander.js-2.4.0/test/test.literal.args.js000066400000000000000000000005671242022011500207540ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-f, --foo', 'add some foo') .option('-b, --bar', 'add some bar'); program.parse(['node', 'test', '--foo', '--', '--bar', 'baz']); program.foo.should.be.true; should.equal(undefined, program.bar); program.args.should.eql(['--bar', 'baz']);commander.js-2.4.0/test/test.options.args.optional.given.js000066400000000000000000000004411242022011500237350ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-c, --cheese [type]', 'optionally specify the type of cheese'); program.parse(['node', 'test', '--cheese', 'feta']); program.cheese.should.equal('feta'); commander.js-2.4.0/test/test.options.args.optional.js000066400000000000000000000004231242022011500226260ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-c, --cheese [type]', 'optionally specify the type of cheese'); program.parse(['node', 'test', '--cheese']); program.cheese.should.be.true; commander.js-2.4.0/test/test.options.bool.js000066400000000000000000000004771242022011500210120ustar00rootroot00000000000000 /** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-p, --pepper', 'add pepper') .option('-c, --no-cheese', 'remove cheese'); program.parse(['node', 'test', '--pepper']); program.pepper.should.be.true; program.cheese.should.be.true; commander.js-2.4.0/test/test.options.bool.no.js000066400000000000000000000005131242022011500214140ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-p, --pepper', 'add pepper') .option('-c|--no-cheese', 'remove cheese'); program.parse(['node', 'test', '--no-cheese']); should.equal(undefined, program.pepper); program.cheese.should.be.false; commander.js-2.4.0/test/test.options.bool.small.combined.js000066400000000000000000000004721242022011500236730ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-p, --pepper', 'add pepper') .option('-c, --no-cheese', 'remove cheese'); program.parse(['node', 'test', '-pc']); program.pepper.should.be.true; program.cheese.should.be.false; commander.js-2.4.0/test/test.options.bool.small.js000066400000000000000000000004771242022011500221210ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-p, --pepper', 'add pepper') .option('-c, --no-cheese', 'remove cheese'); program.parse(['node', 'test', '-p', '-c']); program.pepper.should.be.true; program.cheese.should.be.false; commander.js-2.4.0/test/test.options.camelcase.js000066400000000000000000000015461242022011500217720ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); function parseRange(str) { return str.split('..').map(Number); } program .version('0.0.1') .option('-i, --my-int ', 'pass an int', parseInt) .option('-n, --my-num ', 'pass a number', Number) .option('-f, --my-fLOAT ', 'pass a float', parseFloat) .option('-m, --my-very-long-float ', 'pass a float', parseFloat) .option('-u, --my-URL-count ', 'pass a float', parseFloat) .option('-r, --my-long-range ', 'pass a range', parseRange); program.parse('node test -i 5.5 -f 5.5 -m 6.5 -u 7.5 -n 15.99 -r 1..5'.split(' ')); program.myInt.should.equal(5); program.myNum.should.equal(15.99); program.myFLOAT.should.equal(5.5); program.myVeryLongFloat.should.equal(6.5); program.myURLCount.should.equal(7.5); program.myLongRange.should.eql([1,5]); commander.js-2.4.0/test/test.options.cflags.js000066400000000000000000000012541242022011500213100ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-c, --cflags ', 'pass options/flags to a compiler') .option('-o, --other', 'just some other option') .option('-x, --xother', 'just some other option') .option('-y, --yother', 'just some other option') .option('-z, --zother', 'just some other option'); program.parse(['node', 'test', '--cflags', '-DDEBUG', '-o', '-xyz']); program.should.have.property('cflags', '-DDEBUG'); program.should.have.property('other'); program.should.have.property('xother'); program.should.have.property('yother'); program.should.have.property('zother'); commander.js-2.4.0/test/test.options.coercion.js000066400000000000000000000020151242022011500216460ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); function parseRange(str) { return str.split('..').map(Number); } function increaseVerbosity(v, total) { return total + 1; } function collectValues(str, memo) { memo.push(str); return memo; } program .version('0.0.1') .option('-i, --int ', 'pass an int', parseInt) .option('-n, --num ', 'pass a number', Number) .option('-f, --float ', 'pass a float', parseFloat) .option('-r, --range ', 'pass a range', parseRange) .option('-v, --verbose', 'increase verbosity', increaseVerbosity, 0) .option('-c, --collect ', 'add a string (can be used multiple times)', collectValues, []); program.parse('node test -i 5.5 -f 5.5 -n 15.99 -r 1..5 -c foo -c bar -c baz -vvvv --verbose'.split(' ')); program.int.should.equal(5); program.num.should.equal(15.99); program.float.should.equal(5.5); program.range.should.eql([1,5]); program.collect.should.eql([ 'foo', 'bar', 'baz' ]); program.verbose.should.equal(5); commander.js-2.4.0/test/test.options.commands.js000066400000000000000000000073401242022011500216540ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-C, --chdir ', 'change the working directory') .option('-c, --config ', 'set config path. defaults to ./deploy.conf') .option('-T, --no-tests', 'ignore test hook') var envValue = ""; var cmdValue = ""; var customHelp = false; program .command('setup [env]') .description('run setup commands for all envs') .option("-s, --setup_mode [mode]", "Which setup mode to use") .option("-o, --host [host]", "Host to use") .action(function(env, options){ var mode = options.setup_mode || "normal"; env = env || 'all'; envValue = env; }); program .command('exec ') .alias('ex') .description('execute the given remote cmd') .option("-e, --exec_mode ", "Which exec mode to use") .option("-t, --target [target]", "Target to use") .action(function(cmd, options){ cmdValue = cmd; }).on("--help", function(){ customHelp = true; }); program .command('*') .action(function(env){ console.log('deploying "%s"', env); }); program.parse(['node', 'test', '--config', 'conf']); program.config.should.equal("conf"); program.commands[0].should.not.have.property.setup_mode; program.commands[1].should.not.have.property.exec_mode; envValue.should.equal(""); cmdValue.should.equal(""); program.parse(['node', 'test', '--config', 'conf1', 'setup', '--setup_mode', 'mode3', 'env1']); program.config.should.equal("conf1"); program.commands[0].setup_mode.should.equal("mode3"); program.commands[0].should.not.have.property.host; envValue.should.equal("env1"); program.parse(['node', 'test', '--config', 'conf2', 'setup', '--setup_mode', 'mode3', '-o', 'host1', 'env2']); program.config.should.equal("conf2"); program.commands[0].setup_mode.should.equal("mode3"); program.commands[0].host.should.equal("host1"); envValue.should.equal("env2"); program.parse(['node', 'test', '--config', 'conf3', 'setup', '-s', 'mode4', 'env3']); program.config.should.equal("conf3"); program.commands[0].setup_mode.should.equal("mode4"); envValue.should.equal("env3"); program.parse(['node', 'test', '--config', 'conf4', 'exec', '--exec_mode', 'mode1', 'exec1']); program.config.should.equal("conf4"); program.commands[1].exec_mode.should.equal("mode1"); program.commands[1].should.not.have.property.target; cmdValue.should.equal("exec1"); program.parse(['node', 'test', '--config', 'conf5', 'exec', '-e', 'mode2', 'exec2']); program.config.should.equal("conf5"); program.commands[1].exec_mode.should.equal("mode2"); cmdValue.should.equal("exec2"); program.parse(['node', 'test', '--config', 'conf6', 'exec', '--target', 'target1', '-e', 'mode2', 'exec3']); program.config.should.equal("conf6"); program.commands[1].exec_mode.should.equal("mode2"); program.commands[1].target.should.equal("target1"); cmdValue.should.equal("exec3"); program.parse(['node', 'test', '--config', 'conf7', 'ex', '-e', 'mode3', 'exec4']); program.config.should.equal("conf7"); program.commands[1].exec_mode.should.equal("mode3"); program.commands[1].should.not.have.property.target; cmdValue.should.equal("exec4"); // Make sure we still catch errors with required values for options var exceptionOccurred = false; var oldProcessExit = process.exit; var oldConsoleError = console.error; process.exit = function() { exceptionOccurred = true; throw new Error(); }; console.error = function() {}; try { program.parse(['node', 'test', '--config', 'conf6', 'exec', '--help']); } catch(ex) { program.config.should.equal("conf6"); } try { program.parse(['node', 'test', '--config', 'conf', 'exec', '-t', 'target1', 'exec1', '-e']); } catch(ex) { } process.exit = oldProcessExit; exceptionOccurred.should.be.true; customHelp.should.be.true; commander.js-2.4.0/test/test.options.defaults.given.js000066400000000000000000000016461242022011500227740ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-a, --anchovies', 'Add anchovies?') .option('-o, --onions', 'Add onions?', true) .option('-v, --olives', 'Add olives? Sorry we only have black.', 'black') .option('-s, --no-sauce', 'Uh… okay') .option('-r, --crust ', 'What kind of crust would you like?', 'hand-tossed') .option('-c, --cheese [type]', 'optionally specify the type of cheese', 'mozzarella'); program.parse(['node', 'test', '--anchovies', '--onions', '--olives', '--no-sauce', '--crust', 'thin', '--cheese', 'wensleydale']); program.should.have.property('anchovies', true); program.should.have.property('onions', true); program.should.have.property('olives', 'black'); program.should.have.property('sauce', false); program.should.have.property('crust', 'thin'); program.should.have.property('cheese', 'wensleydale'); commander.js-2.4.0/test/test.options.defaults.js000066400000000000000000000014771242022011500216670ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('-a, --anchovies', 'Add anchovies?') .option('-o, --onions', 'Add onions?', true) .option('-v, --olives', 'Add olives? Sorry we only have black.', 'black') .option('-s, --no-sauce', 'Uh… okay') .option('-r, --crust ', 'What kind of crust would you like?', 'hand-tossed') .option('-c, --cheese [type]', 'optionally specify the type of cheese', 'mozzarella'); program.parse(['node', 'test']); program.should.not.have.property('anchovies'); program.should.not.have.property('onions'); program.should.not.have.property('olives'); program.should.have.property('sauce', true); program.should.have.property('crust', 'hand-tossed'); program.should.have.property('cheese', 'mozzarella'); commander.js-2.4.0/test/test.options.equals.js000066400000000000000000000007211242022011500213410ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('--string ', 'pass a string') .option('--string2 ', 'pass another string') .option('--num ', 'pass a number', Number) program.parse('node test --string=Hello --string2 Hello=World --num=5.5'.split(' ')); program.string.should.equal('Hello'); program.string2.should.equal('Hello=World'); program.num.should.equal(5.5); commander.js-2.4.0/test/test.options.func.js000066400000000000000000000011501242022011500207770ustar00rootroot00000000000000var program = require('../') , should = require('should'); program .version('0.0.1') .description('sdfdsfsfsdfdsf') .option('-f, --foo', 'add some foo') .option('-b, --bar', 'add some bar') .option('-M, --no-magic', 'disable magic') .option('-q, --quux ', 'add some quux'); program.parse(['node', 'test', '--foo', '--bar', '--no-magic', '--quux', 'value']); program.opts.should.be.a.Function; var opts = program.opts(); opts.should.be.an.Object; opts.version.should.equal('0.0.1'); opts.foo.should.be.true; opts.bar.should.be.true; opts.magic.should.be.false; opts.quux.should.equal('value'); commander.js-2.4.0/test/test.options.hyphen.js000066400000000000000000000011241242022011500213400ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); function parseRange(str) { return str.split('..').map(Number); } program .version('0.0.1') .option('-a, --alpha ', 'hyphen') .option('-b, --bravo ', 'hyphen') .option('-c, --charlie ', 'hyphen') program.parse('node test -a - --bravo - --charlie=- - -- - -t1'.split(' ')); program.alpha.should.equal('-'); program.bravo.should.equal('-'); program.charlie.should.equal('-'); program.args[0].should.equal('-'); program.args[1].should.equal('-'); program.args[2].should.equal('-t1'); commander.js-2.4.0/test/test.options.large-only-with-value.js000066400000000000000000000004461242022011500242070ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('--longflag [value]', 'A long only flag with a value'); program.parse(['node', 'test', '--longflag', 'something']); program.longflag.should.equal('something'); commander.js-2.4.0/test/test.options.large-only.js000066400000000000000000000003561242022011500221240ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); program .version('0.0.1') .option('--verbose', 'do stuff'); program.parse(['node', 'test', '--verbose']); program.verbose.should.be.true;