yargs 1.2.2 → 1.2.6

package/.travis.yml

@@ -1,4 +1,3 @@
 language: node_js
 node_js:
   - "0.10"
-  - "0.8"

package/README.md

@@ -9,7 +9,9 @@ With yargs, ye be havin' a map that leads straight to yer treasure! Treasure of
 [![Dependency Status](https://gemnasium.com/chevex/yargs.png)](https://gemnasium.com/chevex/yargs)
 [![NPM version](https://badge.fury.io/js/yargs.png)](http://badge.fury.io/js/yargs)
 
-> NOTE: Yargs is a fork of [optimist](https://github.com/substack/node-optimist) by [substack (James Halliday)](https://github.com/substack). It is obvious that substack is stretched pretty thin maintaining over 300 modules on npm at the time of this writing. So rather than complain in the project issue tracker I thought I'd just pick up the torch and maintain a proper fork. Currently the project is totally backward compatible with optimist but this may change in the future (if it does I will update this notice to inform you of this). For now though, enjoy optimist with about 5 months worth of fixes and updates rolled in, most of them pulled from optimist's own [stale pull requests](https://github.com/substack/node-optimist/pulls).
+> ~~NOTE: Yargs is a fork of [optimist](https://github.com/substack/node-optimist) by [substack (James Halliday)](https://github.com/substack). It is obvious that substack is stretched pretty thin maintaining over 300 modules on npm at the time of this writing. So rather than complain in the project issue tracker I thought I'd just pick up the torch and maintain a proper fork. Currently the project is totally backward compatible with optimist but this may change in the future (if it does I will update this notice to inform you of this). For now though, enjoy optimist with about 5 months worth of fixes and updates rolled in, most of them pulled from optimist's own [stale pull requests](https://github.com/substack/node-optimist/pulls).~~
+
+> UPDATE: Yargs is now the official successor to optimist. Please feel free to submit issues and pull requests. While I personally don't have the time to pour over all the issues and fix all of them on a regular basis, I'm more than happy to look over pull requests, test them, and merge them in. If you'd like to contribute and don't know where to start, have a look at [the issue list](https://github.com/chevex/yargs/issues) :)
 
 examples
 ========
@@ -384,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)
 --------------------
 
@@ -421,13 +433,15 @@ var argv = require('yargs')
 
 Optionally `.options()` can take an object that maps keys to `opt` parameters.
 
-.usage(message)
----------------
+.usage(message, opts)
+---------------------
 
 Set a usage message to show which commands to use. Inside `message`, the string
 `$0` will get interpolated to the current script name or node command for the
 present script similar to how `$0` works in bash or perl.
 
+`opts` is optional and acts like calling `.options(opts)`.
+
 .example(cmd, desc)
 -------------------
 
@@ -476,6 +490,12 @@ is loaded and parsed, and its properties are set as arguments.
 
 Format usage output to wrap at `columns` many columns.
 
+.strict()
+---------
+
+Any command-line argument given that is not demanded, or does not have a
+corresponding description, will be reported as an error.
+
 .help()
 -------
 

package/example/bool.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 var util = require('util');
-var argv = require('optimist').argv;
+var argv = require('yargs').argv;
 
 if (argv.s) {
     util.print(argv.fr ? 'Le chat dit: ' : 'The cat says: ');

package/example/boolean_double.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .boolean(['x','y','z'])
     .argv
 ;

package/example/boolean_single.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .boolean('v')
     .argv
 ;

package/example/count.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .count('verbose')
     .alias('v', 'verbose')
     .argv;
@@ -12,4 +12,4 @@ function DEBUG() { VERBOSE_LEVEL >= 2 && console.log.apply(console, arguments);
 
 WARN("Showing only important stuff");
 INFO("Showing semi-important stuff too");
-DEBUG("Extra chatty mode");
+DEBUG("Extra chatty mode");

package/example/default_hash.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-var argv = require('optimist')
+var argv = require('yargs')
     .default({ x : 10, y : 10 })
     .argv
 ;

package/example/default_singles.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .default('x', 10)
     .default('y', 10)
     .argv

package/example/demand_count.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .demand(2)
     .argv;
 console.dir(argv)

package/example/divide.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-var argv = require('optimist')
+var argv = require('yargs')
     .usage('Usage: $0 -x [num] -y [num]')
     .demand(['x','y'])
     .argv;

package/example/implies.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
-var argv = require('../index')
+var argv = require('yargs')
     .usage('Usage: $0 -x [num] -y [num]')
     .implies('x', 'y')
     .argv;
 
 if (argv.x) {
     console.log(argv.x / argv.y);
-}
+}

package/example/implies_hash.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-var argv = require('../index')
+var argv = require('yargs')
     .usage('Usage: $0 -x [num] -y [num] -w [msg] -h [msg]')
     .implies({
         x: 'y',
@@ -23,4 +23,4 @@ if (argv.w) {
 
 if (argv.h) {
     console.log('h: ' +argv.h);
-}
+}

package/example/line_count.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .usage('Count the lines in a file.\nUsage: $0')
     .demand('f')
     .alias('f', 'file')

package/example/line_count_options.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .usage('Count the lines in a file.\nUsage: $0')
     .options({
         file : {

package/example/line_count_wrap.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .usage('Count the lines in a file.\nUsage: $0')
     .wrap(80)
     .demand('f')

package/example/nonopt.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-var argv = require('optimist').argv;
+var argv = require('yargs').argv;
 console.log('(%d,%d)', argv.x, argv.y);
 console.log(argv._);

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/example/short.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-var argv = require('optimist').argv;
+var argv = require('yargs').argv;
 console.log('(%d,%d)', argv.x, argv.y);

package/example/strict.js

@@ -0,0 +1,19 @@
+var yargs = require('yargs');
+
+var argv = yargs.usage('This is my awesome program', {
+  'about': {
+    description: 'Provide some details about the author of this program',
+    boolean: true,
+    short: 'a',
+  },
+  'info': {
+    description: 'Provide some information about this program',
+    boolean: true,
+    short: 'i'
+  }
+}).strict().argv;
+
+yargs.showHelp();
+
+console.log('\n\nInspecting options');
+console.dir(argv);

package/example/string.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist')
+var argv = require('yargs')
     .string('x', 'y')
     .argv
 ;

package/example/usage-options.js

@@ -1,6 +1,6 @@
-var optimist = require('./../index');
+var yargs = require('yargs');
 
-var argv = optimist.usage('This is my awesome program', {
+var argv = yargs.usage('This is my awesome program', {
   'about': {
     description: 'Provide some details about the author of this program',
     required: true,
@@ -13,7 +13,7 @@ var argv = optimist.usage('This is my awesome program', {
   }
 }).argv;
 
-optimist.showHelp();
+yargs.showHelp();
 
 console.log('\n\nInspecting options');
-console.dir(argv);
+console.dir(argv);

package/example/xup.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var argv = require('optimist').argv;
+var argv = require('yargs').argv;
 
 if (argv.rif - 5 * argv.xup > 7.138) {
     console.log('Buy more riffiwobbles');
@@ -7,4 +7,3 @@ if (argv.rif - 5 * argv.xup > 7.138) {
 else {
     console.log('Sell the xupptumblers');
 }
-

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;
@@ -235,6 +245,12 @@ function Argv (processArgs, cwd) {
         wrap = cols;
         return self;
     };
+
+    var strict = false;
+    self.strict = function () {
+        strict = true;
+        return self;
+    };
     
     self.showHelp = function (fn) {
         if (!fn) fn = console.error.bind(console);
@@ -281,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) {
@@ -290,7 +311,7 @@ function Argv (processArgs, cwd) {
             ;
             return acc;
         }, {});
-        
+
         var switchlen = longest(Object.keys(switches).map(function (s) {
             return switches[s] || '';
         }));
@@ -385,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) {
@@ -406,7 +448,35 @@ function Argv (processArgs, cwd) {
 
             fail('Missing required arguments: ' + Object.keys(missing).join(', ') + customMsg);
         }
-        
+
+        if (strict) {
+            var unknown = [];
+
+            var aliases = {};
+
+            Object.keys(options.alias).forEach(function (key) {
+                options.alias[key].forEach(function (alias) {
+                    aliases[alias] = key;
+                });
+            });
+
+            Object.keys(argv).forEach(function (key) {
+                if (key !== "$0" && key !== "_" &&
+                    !descriptions.hasOwnProperty(key) &&
+                    !demanded.hasOwnProperty(key) &&
+                    !aliases.hasOwnProperty(key)) {
+                    unknown.push(key);
+                }
+            });
+
+            if (unknown.length == 1) {
+                fail("Unknown argument: " + unknown[0]);
+            }
+            else if (unknown.length > 1) {
+                fail("Unknown arguments: " + unknown.join(", "));
+            }
+        }
+
         checks.forEach(function (f) {
             try {
                 var result = f(argv, aliases);

package/lib/minimist.js

@@ -50,6 +50,15 @@ module.exports = function (args, opts) {
 
     var defaults = opts['default'] || {};
 
+    Object.keys(defaults || {}).forEach(function (key) {
+        if (/-/.test(key) && !opts.alias[key]) {
+            aliases[key] = (aliases[key] || []).concat(toCamelCase(key));
+        }
+        (aliases[key] || []).forEach(function (alias) {
+            defaults[alias] = defaults[key];
+        });
+    });
+
     var argv = { _ : [] };
     Object.keys(flags.bools).forEach(function (key) {
         setArg(key, defaults[key] === undefined ? false : defaults[key]);
@@ -76,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,10 +1,10 @@
 {
   "name": "yargs",
-  "version": "1.2.2",
+  "version": "1.2.6",
   "description": "Light-weight option parsing with an argv hash. No optstrings attached.",
   "main": "./index.js",
   "dependencies": {
-    "minimist": "~0.0.1"
+    "minimist": "^0.1.0"
   },
   "devDependencies": {
     "hashish": "*",

package/test/parse_camelCase.js

@@ -34,6 +34,41 @@ describe('parse', function () {
             result.should.have.property('someOption').that.is.a('boolean').and.is.true;
         });
 
+        it('should provide defaults of options with dashes as camelCase properties', function() {
+            var result = yargs()
+                .option('some-option', {
+                    describe : 'some option',
+                    default  : 'asdf'
+                })
+                .parse([ ]);
+
+            result.should.have.property('someOption', 'asdf');
+        });
+
+        it('should provide aliases of options with dashes as camelCase properties', function() {
+            var result = yargs()
+                .option('some-option', {
+                    alias    : 'o',
+                    describe : 'some option',
+                    default  : 'asdf'
+                })
+                .parse([ ]);
+
+            result.should.have.property('o', 'asdf');
+        });
+
+        it('should provide aliases of options with dashes as camelCase properties', function() {
+            var result = yargs()
+                .option('o', {
+                    alias    : 'some-option',
+                    describe : 'some option',
+                    default  : 'asdf'
+                })
+                .parse([ ]);
+
+            result.should.have.property('someOption', 'asdf');
+        });
+
         it('should provide aliases with dashes as camelCase properties', function() {
             var result = yargs()
                 .option('o', {

package/test/parse_defaults.js

@@ -0,0 +1,82 @@
+var should = require('chai').should(),
+    yargs = require('../');
+
+describe('parse', function () {
+
+    describe('defaults', function () {
+        function checkNoArgs(argv, hasAlias) {
+            it('should set defaults if no args', function() {
+                var result = argv.parse([ ]);
+                result.should.have.property('flag', true);
+                if (hasAlias) {
+                    result.should.have.property('f', true);
+                }
+            });
+        }
+
+        function checkExtraArg(argv, hasAlias) {
+            it('should set defaults if one extra arg', function() {
+                var result = argv.parse([ 'extra' ]);
+                result.should.have.property('flag', true);
+                result.should.have.property('_').and.deep.equal(['extra']);
+                if (hasAlias) {
+                    result.should.have.property('f', true);
+                }
+            });
+        }
+
+        function checkStringArg(argv, hasAlias) {
+            it('should set defaults even if arg looks like a string', function() {
+                var result = argv.parse([ '--flag', 'extra' ]);
+                result.should.have.property('flag', true);
+                result.should.have.property('_').and.deep.equal(['extra']);
+                if (hasAlias) {
+                    result.should.have.property('f', true);
+                }
+            });
+        }
+
+        describe('for options with aliases', function () {
+            var args = yargs().options({
+                flag : {
+                    alias   : 'f',
+                    default : true
+                }
+            });
+
+            checkNoArgs(args, true);
+            checkExtraArg(args, true);
+            // This test case should fail, because we didn't specify that the
+            // option is a boolean
+            // checkStringArg(args, true);
+        });
+
+        describe('for typed options without aliases', function () {
+            var args = yargs().options({
+                flag : {
+                    type    : 'boolean',
+                    default : true
+                }
+            });
+
+            checkNoArgs(args);
+            checkExtraArg(args);
+            checkStringArg(args);
+        });
+
+        describe('for typed options with aliases', function () {
+            var args = yargs().options({
+                flag : {
+                    alias   : 'f',
+                    type    : 'boolean',
+                    default : true
+                }
+            });
+
+            checkNoArgs(args, true);
+            checkExtraArg(args, true);
+            checkStringArg(args, true);
+        });
+    });
+
+});

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,209 @@ 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 () {
+                opts = {
+                    foo: { demand: 'foo option', alias: 'f' },
+                    bar: { demand: 'bar option', alias: 'b' }
+                };
+
+                return yargs('-f 10 --bar 20 --baz 30'.split(' '))
+                    .usage('Usage: $0 [options]', opts)
+                    .strict()
+                    .argv;
+            });
+
+            r.should.have.property('result');
+            r.result.should.have.property('_').with.length(0);
+            r.result.should.have.property('f', 10);
+            r.result.should.have.property('foo', 10);
+            r.result.should.have.property('b', 20);
+            r.result.should.have.property('bar', 20);
+            r.result.should.have.property('baz', 30);
+            r.should.have.property('errors');
+            r.errors.join('\n').split(/\n+/).should.deep.equal([
+                'Usage: ./usage [options]',
+                'Options:',
+                '  --foo, -f  [required]',
+                '  --bar, -b  [required]',
+                'Unknown argument: baz',
+            ]);
+            r.should.have.property('logs').with.length(0);
+            r.should.have.property('exit').and.be.ok;
+        });
+
+        it('should fail given an option argument without a corresponding description', function () {
+            var r = checkUsage(function () {
+                opts = {
+                    foo: { description: 'foo option', alias: 'f' },
+                    bar: { description: 'bar option', alias: 'b' }
+                };
+
+                return yargs('-f 10 --bar 20 --baz 30'.split(' '))
+                    .usage('Usage: $0 [options]', opts)
+                    .strict()
+                    .argv;
+            });
+
+            r.should.have.property('result');
+            r.result.should.have.property('_').with.length(0);
+            r.result.should.have.property('f', 10);
+            r.result.should.have.property('foo', 10);
+            r.result.should.have.property('b', 20);
+            r.result.should.have.property('bar', 20);
+            r.result.should.have.property('baz', 30);
+            r.should.have.property('errors');
+            r.errors.join('\n').split(/\n+/).should.deep.equal([
+                'Usage: ./usage [options]',
+                'Options:',
+                '  --foo, -f  foo option',
+                '  --bar, -b  bar option',
+                'Unknown argument: baz',
+            ]);
+            r.should.have.property('logs').with.length(0);
+            r.should.have.property('exit').and.be.ok;
+        });
+
+        it('should fail given multiple option arguments without corresponding descriptions', function () {
+            var r = checkUsage(function () {
+                opts = {
+                    foo: { description: 'foo option', alias: 'f' },
+                    bar: { description: 'bar option', alias: 'b' }
+                };
+
+                return yargs('-f 10 --bar 20 --baz 30 -q 40'.split(' '))
+                    .usage('Usage: $0 [options]', opts)
+                    .strict()
+                    .argv;
+            });
+
+            r.should.have.property('result');
+            r.result.should.have.property('_').with.length(0);
+            r.result.should.have.property('f', 10);
+            r.result.should.have.property('foo', 10);
+            r.result.should.have.property('b', 20);
+            r.result.should.have.property('bar', 20);
+            r.result.should.have.property('baz', 30);
+            r.result.should.have.property('q', 40);
+            r.should.have.property('errors');
+            r.errors.join('\n').split(/\n+/).should.deep.equal([
+                'Usage: ./usage [options]',
+                'Options:',
+                '  --foo, -f  foo option',
+                '  --bar, -b  bar option',
+                'Unknown arguments: baz, q',
+            ]);
+            r.should.have.property('logs').with.length(0);
+            r.should.have.property('exit').and.be.ok;
+        });
+
+        it('should pass given option arguments with corresponding descriptions', function () {
+            var r = checkUsage(function () {
+                opts = {
+                    foo: { description: 'foo option' },
+                    bar: { description: 'bar option' }
+                };
+
+                return yargs('--foo 10 --bar 20'.split(' '))
+                    .usage('Usage: $0 [options]', opts)
+                    .strict()
+                    .argv;
+            });
+
+            r.should.have.property('result');
+            r.result.should.have.property('foo', 10);
+            r.result.should.have.property('bar', 20)
+            r.result.should.have.property('_').with.length(0);
+            r.should.have.property('errors').with.length(0);
+            r.should.have.property('logs').with.length(0);
+            r.should.have.property('exit', false);
+        });
+    });
+
     it('should display example on fail', function () {
         var r = checkUsage(function () {
             return yargs('')