yargs 1.2.5 → 1.2.6

package/README.md

@@ -386,6 +386,16 @@ If `key` is an Array, demand each element.
 If `msg` is supplied, it will be printed when the argument is missing,
 instead of the standard error message. This is especially helpful for the non-option arguments in `argv._`.
 
+.requiresArg(key)
+-----------------
+
+Specifies either a single option key (string), or an array of options that
+must be followed by option values. If any option value is missing, show the
+usage information and exit.
+
+The default behaviour is to set the value of any key not followed by an
+option value to `true`.
+
 .describe(key, desc)
 --------------------
 

package/example/requires_arg.js

@@ -0,0 +1,19 @@
+var yargs = require('yargs');
+
+var argv = yargs.usage('This is my awesome program', {
+  'input': {
+    description: 'Input file name',
+    requiresArg: true,
+    short: 'i',
+  },
+  'output': {
+    description: 'Output file name',
+    requiresArg: true,
+    short: 'o'
+  }
+}).argv;
+
+yargs.showHelp();
+
+console.log('\n\nInspecting options');
+console.dir(argv);

package/index.js

@@ -45,6 +45,7 @@ function Argv (processArgs, cwd) {
             string: [],
             alias: {},
             default: [],
+            requiresArg: [],
             count: [],
             normalize: [],
             config: []
@@ -127,6 +128,11 @@ function Argv (processArgs, cwd) {
         return self;
     };
 
+    self.requiresArg = function (requiresArgs) {
+        options.requiresArg.push.apply(options.requiresArg, [].concat(requiresArgs));
+        return self;
+    };
+
     var implied = {};
     self.implies = function (key, value) {
         if (typeof key === 'object') {
@@ -225,6 +231,10 @@ function Argv (processArgs, cwd) {
             if (desc) {
                 self.describe(key, desc);
             }
+
+            if (opt.requiresArg) {
+                self.requiresArg(key);
+            }
         }
         
         return self;
@@ -287,6 +297,11 @@ function Argv (processArgs, cwd) {
             help.unshift(usage.replace(/\$0/g, self.$0), '');
         }
 
+        keys = keys.filter(function(key) {
+            return Object.keys(options.alias).every(function(alias) {
+                return -1 == options.alias[alias].indexOf(key);
+            });
+        });
         var switches = keys.reduce(function (acc, key) {
             acc[key] = [ key ].concat(options.alias[key] || [])
                 .map(function (sw) {
@@ -296,7 +311,7 @@ function Argv (processArgs, cwd) {
             ;
             return acc;
         }, {});
-        
+
         var switchlen = longest(Object.keys(switches).map(function (s) {
             return switches[s] || '';
         }));
@@ -391,6 +406,27 @@ function Argv (processArgs, cwd) {
                 );
             }
         }
+
+        if (options.requiresArg.length > 0) {
+            var missingRequiredArgs = [];
+
+            options.requiresArg.forEach(function(key) {
+                var value = argv[key];
+
+                // minimist sets --foo value to true / --no-foo to false
+                if (value === true || value === false) {
+                    missingRequiredArgs.push(key);
+                }
+            });
+
+            if (missingRequiredArgs.length == 1) {
+                fail("Missing argument value: " + missingRequiredArgs[0]);
+            }
+            else if (missingRequiredArgs.length > 1) {
+                message = "Missing argument values: " + missingRequiredArgs.join(", ");
+                fail(message);
+            }
+        }
         
         var missing = null;
         Object.keys(demanded).forEach(function (key) {

package/lib/minimist.js

@@ -85,7 +85,6 @@ module.exports = function (args, opts) {
         if (flags.configs[key]) {
             try {
                 var config = JSON.parse(fs.readFileSync(val, 'utf8'));
-                console.warn(config);
                 Object.keys(config).forEach(function (key) {
                     setArg(key, config[key]);
                 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yargs",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "Light-weight option parsing with an argv hash. No optstrings attached.",
   "main": "./index.js",
   "dependencies": {

package/test/usage.js

@@ -275,6 +275,22 @@ describe('usage', function () {
         r.result.should.have.property('_').with.length(0);
     });
 
+    it('should print a single line when failing and default is set for an alias', function() {
+        var r = checkUsage(function() {
+            return yargs('')
+                .alias('f', 'foo')
+                .default('f', 5)
+                .demand(1)
+                .argv
+            ;
+        });
+        r.errors.join('\n').split(/\n+/).should.deep.equal([
+            'Options:',
+            '  -f, --foo  [default: 5]',
+            'Not enough non-option arguments: got 0, need at least 1',
+        ]);
+    });
+
     it('should allow you to set default values for a hash of options', function () {
         var r = checkUsage(function () {
             return yargs('--foo 50 --baz 70'.split(' '))
@@ -290,6 +306,88 @@ describe('usage', function () {
         r.result.should.have.property('quux', 30);
     });
 
+    describe('required arguments', function () {
+        describe('with options object', function () {
+            it('should show a failure message if a required option is missing', function () {
+                var r = checkUsage(function () {
+                    var opts = {
+                        foo: { description: 'foo option', alias: 'f', requiresArg: true },
+                        bar: { description: 'bar option', alias: 'b', requiresArg: true }
+                    };
+
+                    return yargs('-f --bar 20'.split(' '))
+                        .usage('Usage: $0 [options]', opts)
+                        .argv;
+                });
+                r.should.have.property('result');
+                r.result.should.have.property('_').with.length(0);
+                r.should.have.property('errors');
+                r.should.have.property('logs').with.length(0);
+                r.should.have.property('exit').and.be.ok;
+                r.errors.join('\n').split(/\n+/).should.deep.equal([
+                    'Usage: ./usage [options]',
+                    'Options:',
+                    '  --foo, -f  foo option',
+                    '  --bar, -b  bar option',
+                    'Missing argument value: foo',
+                ]);
+            });
+
+            it('should show a failure message if more than one required option is missing', function () {
+                var r = checkUsage(function () {
+                    var opts = {
+                        foo: { description: 'foo option', alias: 'f', requiresArg: true },
+                        bar: { description: 'bar option', alias: 'b', requiresArg: true }
+                    };
+
+                    return yargs('-f --bar'.split(' '))
+                        .usage('Usage: $0 [options]', opts)
+                        .argv;
+                });
+                r.should.have.property('result');
+                r.result.should.have.property('_').with.length(0);
+                r.should.have.property('errors');
+                r.should.have.property('logs').with.length(0);
+                r.should.have.property('exit').and.be.ok;
+                r.errors.join('\n').split(/\n+/).should.deep.equal([
+                    'Usage: ./usage [options]',
+                    'Options:',
+                    '  --foo, -f  foo option',
+                    '  --bar, -b  bar option',
+                    'Missing argument values: foo, bar',
+                ]);
+            });
+        });
+
+        describe('with requiresArg method', function () {
+            it('should show a failure message if a required option is missing', function () {
+                var r = checkUsage(function () {
+                    var opts = {
+                        foo: { description: 'foo option', alias: 'f' },
+                        bar: { description: 'bar option', alias: 'b' }
+                    };
+
+                    return yargs('-f --bar 20'.split(' '))
+                        .usage('Usage: $0 [options]', opts)
+                        .requiresArg(['foo', 'bar'])
+                        .argv;
+                });
+                r.should.have.property('result');
+                r.result.should.have.property('_').with.length(0);
+                r.should.have.property('errors');
+                r.should.have.property('logs').with.length(0);
+                r.should.have.property('exit').and.be.ok;
+                r.errors.join('\n').split(/\n+/).should.deep.equal([
+                    'Usage: ./usage [options]',
+                    'Options:',
+                    '  --foo, -f  foo option',
+                    '  --bar, -b  bar option',
+                    'Missing argument value: foo',
+                ]);
+            });
+        });
+    });
+
     context("with strict() option set", function () {
         it('should fail given an option argument that is not demanded', function () {
             var r = checkUsage(function () {