pax_global_header00006660000000000000000000000064121721071160014510gustar00rootroot0000000000000052 comment=efc585c7831f589a9ab0c9e34ed8a9ac5b97acbf commander.js-2.0.0/000077500000000000000000000000001217210711600140675ustar00rootroot00000000000000commander.js-2.0.0/.gitignore000066400000000000000000000000361217210711600160560ustar00rootroot00000000000000.DS_Store node_modules *.sock commander.js-2.0.0/.npmignore000066400000000000000000000000751217210711600160700ustar00rootroot00000000000000support test examples *.sock .npmignore .travis.yml Makefile commander.js-2.0.0/.travis.yml000066400000000000000000000000531217210711600161760ustar00rootroot00000000000000language: node_js node_js: - 0.4 - 0.6 commander.js-2.0.0/History.md000066400000000000000000000071521217210711600160570ustar00rootroot00000000000000 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.0.0/Makefile000066400000000000000000000001201217210711600155200ustar00rootroot00000000000000 TESTS = $(shell find test/test.*.js) test: @./test/run $(TESTS) .PHONY: testcommander.js-2.0.0/Readme.md000066400000000000000000000130211217210711600156030ustar00rootroot00000000000000# 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://secure.travis-ci.org/visionmedia/commander.js.png)](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(','); } 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') .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(' 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('../'); function list(val) { return val.split(',').map(Number); } 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.0.0/examples/000077500000000000000000000000001217210711600157055ustar00rootroot00000000000000commander.js-2.0.0/examples/coercion000077500000000000000000000015401217210711600174340ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); function range(val) { return val.split('..').map(Number); } function list(val) { return val.split(','); } 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') .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(' args: %j', program.args);commander.js-2.0.0/examples/custom-help000077500000000000000000000011301217210711600200660ustar00rootroot00000000000000#!/usr/bin/env node /** * Module dependencies. */ var program = require('../'); function list(val) { return val.split(',').map(Number); } 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.0.0/examples/defaults000077500000000000000000000011371217210711600174440ustar00rootroot00000000000000#!/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.0.0/examples/deploy000077500000000000000000000022571217210711600171350ustar00rootroot00000000000000#!/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 ') .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.0.0/examples/express000077500000000000000000000007741217210711600173340ustar00rootroot00000000000000#!/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.0.0/examples/help000077500000000000000000000004631217210711600165660ustar00rootroot00000000000000#!/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.0.0/examples/pizza000077500000000000000000000013351217210711600167720ustar00rootroot00000000000000#!/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.0.0/examples/pm000077500000000000000000000014571217210711600162560ustar00rootroot00000000000000#!/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.0.0/examples/pm-install000077500000000000000000000006051217210711600177140ustar00rootroot00000000000000#!/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.0.0/index.js000066400000000000000000000444621217210711600155460ustar00rootroot00000000000000 /** * Module dependencies. */ var EventEmitter = require('events').EventEmitter; var spawn = require('child_process').spawn; var fs = require('fs'); var exists = fs.existsSync; 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; this.parent.on(this._name, function(args, unknown){ // Parse any so-far unknown options 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(this, args); }); 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 false * program.option('-C, --no-cheese', 'remove cheese'); * * program.cheese * // => true * * --no-cheese * program.cheese * // => true * * // 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 ('function' != typeof fn) 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); // 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]); // 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]) 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]) + '-' + args[0]; // check for ./ first var local = path.join(dir, bin); // run it args = args.slice(1); var proc = spawn(local, 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 , index; for (var i = 0, len = args.length; i < len; ++i) { arg = args[i]; 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 cmds = this.commands , len = cmds.length , 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); if ('-' == arg[0] && '-' != arg) return this.optionMissingArgument(option, arg); 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 }; }; /** * 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(){ console.log(str); process.exit(0); }); return this; }; /** * Set the description `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 / 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 : ''); if (0 == arguments.length) return this._usage || usage; this._usage = str; return this; }; /** * 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 ''; return [ '' , ' Commands:' , '' , this.commands.map(function(cmd){ var args = cmd._args.map(function(arg){ return arg.required ? '<' + arg.name + '>' : '[' + arg.name + ']'; }).join(' '); return pad(cmd._name + (cmd.options.length ? ' [options]' : '') + ' ' + args, 22) + (cmd.description() ? ' ' + cmd.description() : ''); }).join('\n').replace(/^/gm, ' ') , '' ].join('\n'); }; /** * Return program help documentation. * * @return {String} * @api private */ Command.prototype.helpInformation = function(){ return [ '' , ' Usage: ' + this._name + ' ' + 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.0.0/package.json000066400000000000000000000007461217210711600163640ustar00rootroot00000000000000{ "name": "commander" , "version": "2.0.0" , "description": "the complete solution for node.js command-line programs" , "keywords": ["command", "option", "parser", "prompt", "stdin"] , "author": "TJ Holowaychuk " , "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" } } commander.js-2.0.0/test/000077500000000000000000000000001217210711600150465ustar00rootroot00000000000000commander.js-2.0.0/test/run000077500000000000000000000004271217210711600156030ustar00rootroot00000000000000#!/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.0.0/test/test.literal.args.js000066400000000000000000000005671217210711600207610ustar00rootroot00000000000000/** * 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.0.0/test/test.options.args.optional.given.js000066400000000000000000000004411217210711600237420ustar00rootroot00000000000000/** * 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.0.0/test/test.options.args.optional.js000066400000000000000000000004231217210711600226330ustar00rootroot00000000000000/** * 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.0.0/test/test.options.bool.js000066400000000000000000000004771217210711600210170ustar00rootroot00000000000000 /** * 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.0.0/test/test.options.bool.no.js000066400000000000000000000005131217210711600214210ustar00rootroot00000000000000/** * 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.0.0/test/test.options.bool.small.combined.js000066400000000000000000000004721217210711600237000ustar00rootroot00000000000000/** * 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.0.0/test/test.options.bool.small.js000066400000000000000000000004771217210711600221260ustar00rootroot00000000000000/** * 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.0.0/test/test.options.camelcase.js000066400000000000000000000015461217210711600217770ustar00rootroot00000000000000/** * 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.0.0/test/test.options.coercion.js000066400000000000000000000011441217210711600216550ustar00rootroot00000000000000/** * Module dependencies. */ var program = require('../') , should = require('should'); function parseRange(str) { return str.split('..').map(Number); } 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); program.parse('node test -i 5.5 -f 5.5 -n 15.99 -r 1..5'.split(' ')); program.int.should.equal(5); program.num.should.equal(15.99); program.float.should.equal(5.5); program.range.should.eql([1,5]); commander.js-2.0.0/test/test.options.commands.js000066400000000000000000000067101217210711600216610ustar00rootroot00000000000000/** * 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 ') .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.be.null; cmdValue.should.be.null; 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"); // 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.0.0/test/test.options.defaults.given.js000066400000000000000000000016461217210711600230010ustar00rootroot00000000000000/** * 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.0.0/test/test.options.defaults.js000066400000000000000000000014771217210711600216740ustar00rootroot00000000000000/** * 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.0.0/test/test.options.equals.js000066400000000000000000000007211217210711600213460ustar00rootroot00000000000000/** * 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.0.0/test/test.options.hyphen.js000066400000000000000000000010531217210711600213460ustar00rootroot00000000000000/** * 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=- - -- -'.split(' ')); program.alpha.should.equal('-'); program.bravo.should.equal('-'); program.charlie.should.equal('-'); program.args[0].should.equal('-'); program.args[1].should.equal('-'); commander.js-2.0.0/test/test.options.large-only-with-value.js000066400000000000000000000004461217210711600242140ustar00rootroot00000000000000/** * 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.0.0/test/test.options.large-only.js000066400000000000000000000003561217210711600221310ustar00rootroot00000000000000/** * 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;