yargs 6.3.0 → 6.6.0

package/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+<a name="6.6.0"></a>
+# [6.6.0](https://github.com/yargs/yargs/compare/v6.5.0...v6.6.0) (2016-12-29)
+
+
+### Bug Fixes
+
+* [object Object] was accidentally being populated on options object ([#736](https://github.com/yargs/yargs/issues/736)) ([f755e27](https://github.com/yargs/yargs/commit/f755e27))
+* do not use cwd when resolving package.json for yargs parsing config ([#726](https://github.com/yargs/yargs/issues/726)) ([9bdaab7](https://github.com/yargs/yargs/commit/9bdaab7))
+
+
+### Features
+
+* implement conflicts() for defining mutually exclusive arguments; thanks [@madcampos](https://github.com/madcampos)! ([#741](https://github.com/yargs/yargs/issues/741)) ([5883779](https://github.com/yargs/yargs/commit/5883779))
+* split demand() into demandCommand()/demandOption() ([#740](https://github.com/yargs/yargs/issues/740)) ([66573c8](https://github.com/yargs/yargs/commit/66573c8))
+* support for positional argument aliases ([#727](https://github.com/yargs/yargs/issues/727)) ([27e1a57](https://github.com/yargs/yargs/commit/27e1a57))
+
+
+
+<a name="6.5.0"></a>
+# [6.5.0](https://github.com/yargs/yargs/compare/v6.4.0...v6.5.0) (2016-12-01)
+
+
+### Bug Fixes
+
+* still freeze/unfreeze if parse() is called in isolation ([#717](https://github.com/yargs/yargs/issues/717)) ([30a9492](https://github.com/yargs/yargs/commit/30a9492))
+
+
+### Features
+
+* pull in yargs-parser introducing additional settings ([#688](https://github.com/yargs/yargs/issues/688)), and fixing [#716](https://github.com/yargs/yargs/issues/716) ([#722](https://github.com/yargs/yargs/issues/722)) ([702995a](https://github.com/yargs/yargs/commit/702995a))
+
+
+
+<a name="6.4.0"></a>
+# [6.4.0](https://github.com/yargs/yargs/compare/v6.3.0...v6.4.0) (2016-11-13)
+
+
+### Bug Fixes
+
+* **locales:** correct some Russian translations ([#691](https://github.com/yargs/yargs/issues/691)) ([a980671](https://github.com/yargs/yargs/commit/a980671))
+
+
+### Features
+
+* **locales:** Added Belarusian translation ([#690](https://github.com/yargs/yargs/issues/690)) ([68dac1f](https://github.com/yargs/yargs/commit/68dac1f))
+* **locales:** Create nl.json ([#687](https://github.com/yargs/yargs/issues/687)) ([46ce1bb](https://github.com/yargs/yargs/commit/46ce1bb))
+* update to yargs-parser that addresses [#598](https://github.com/yargs/yargs/issues/598), [#617](https://github.com/yargs/yargs/issues/617) ([#700](https://github.com/yargs/yargs/issues/700)) ([54cb31d](https://github.com/yargs/yargs/commit/54cb31d))
+* yargs is now passed as the third-argument to fail handler ([#613](https://github.com/yargs/yargs/issues/613)) ([21b74f9](https://github.com/yargs/yargs/commit/21b74f9))
+
+
+### Performance Improvements
+
+* normalizing package data is an expensive operation ([#705](https://github.com/yargs/yargs/issues/705)) ([49cf533](https://github.com/yargs/yargs/commit/49cf533))
+
+
+
 <a name="6.3.0"></a>
 # [6.3.0](https://github.com/yargs/yargs/compare/v6.2.0...v6.3.0) (2016-10-19)
 

package/README.md

@@ -42,7 +42,7 @@ if (argv.ships > 3 && argv.distance < 53.5) {
     $ ./plunder.js --ships 12 --distance 98.7
     Retreat from the xupptumblers!
 
-![Joe was one optimistic pirate.](http://i.imgur.com/4WFGVJ9.png)
+![Joe was one optimistic pirate.](https://i.imgur.com/4WFGVJ9.png)
 
 But don't walk the plank just yet! There be more! You can do short options:
 -------------------------------------------------
@@ -160,7 +160,7 @@ area.js:
 #!/usr/bin/env node
 var argv = require('yargs')
     .usage('Usage: $0 -w [num] -h [num]')
-    .demand(['w','h'])
+    .demandOption(['w','h'])
     .argv;
 
 console.log("The area is:", argv.w * argv.h);
@@ -188,7 +188,7 @@ demand_count.js:
 ````javascript
 #!/usr/bin/env node
 var argv = require('yargs')
-    .demand(2)
+    .demandCommand(2)
     .argv;
 console.dir(argv);
 ````
@@ -298,7 +298,7 @@ var argv = require('yargs')
     .alias('f', 'file')
     .nargs('f', 1)
     .describe('f', 'Load a file')
-    .demand(1, ['f'])
+    .demandOption(['f'])
     .help('h')
     .alias('h', 'help')
     .epilog('copyright 2015')
@@ -609,6 +609,21 @@ yargs.command('get <source> [proxy]', 'make a get HTTP request')
   .argv
 ```
 
+#### Positional Argument Aliases
+
+Aliases can be provided for positional arguments using the `|` character.
+As an example, suppose our application allows either a username _or_
+an email as the first argument:
+
+```js
+yargs.command('get <username|email> [password]', 'fetch a user by username or email.')
+  .help()
+  .argv
+```
+
+In this way, both `argv.username` and `argv.email` would be populated with the
+same value when the command is executed.
+
 #### Variadic Positional Arguments
 
 The last positional argument can optionally accept an array of
@@ -663,7 +678,7 @@ require('yargs')
       console.log(`setting ${argv.key} to ${argv.value}`)
     }
   })
-  .demand(1)
+  .demandCommand(1)
   .help()
   .wrap(72)
   .argv
@@ -809,7 +824,7 @@ cli.js:
 #!/usr/bin/env node
 require('yargs')
   .commandDir('cmds')
-  .demand(1)
+  .demandCommand(1)
   .help()
   .argv
 ```
@@ -970,6 +985,13 @@ $ node test.js
   '$0': 'test.js' }
 ```
 
+<a name="conflicts"></a>.conflicts(x, y)
+----------------------------------------------
+
+Given the key `x` is set, the key `y` must not be set.
+
+Optionally `.conflicts()` can accept an object specifying multiple conflicting keys.
+
 <a name="count"></a>.count(key)
 ------------
 
@@ -1005,45 +1027,127 @@ displaying the value in the usage instructions:
 .default('timeout', 60000, '(one-minute)')
 ```
 
-<a name="demand"></a>.demand(key, [msg | boolean])
+<a name="demand"></a>.demand(count, [max], [msg]) [DEPRECATED]
+--------------------
+
+`demand()` has been deprecated, please instead see [`demandOption()`](#demandOption) and
+[`demandCommand()`](#demandCommand).
+
+<a name="demandOption"></a>.demandOption(key, [msg | boolean])
 ------------------------------
-.demand(count, [max], [msg])
+.demandOption(key, msg)
 ------------------------------
 
 If `key` is a string, show the usage information and exit if `key` wasn't
 specified in `process.argv`.
 
-If `key` is a number, demand at least as many non-option arguments, which show
-up in `argv._`. A second number can also optionally be provided, which indicates
-the maximum number of non-option arguments.
-
 If `key` is an array, demand each element.
 
-If a `msg` string is given, 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._`.
+If a `msg` string is given, it will be printed when the argument is missing, instead of the standard error message.
+
+```javascript
+// demand an array of keys to be provided
+require('yargs')
+  .option('run', {
+    alias: 'r',
+    describe: 'run your program'
+  })
+  .option('path', {
+    alias: 'p',
+    describe: 'provide a path to file'
+  })
+  .option('spec', {
+    alias: 's',
+    describe: 'program specifications'
+  })
+  .demandOption(['run', 'path'], 'Please provide both run and path arguments to work with this tool')
+  .help()
+  .argv
+```
+which will provide the following output:
+```bash
+Options:
+  --run, -r   run your program                [required]
+  --path, -p  provide a path to file          [required]
+  --spec, -s  program specifications
+  --help      Show help                        [boolean]
+
+  Missing required arguments: run, path
+  Please provide both run and path arguments to work with this tool
+```
 
 If a `boolean` value is given, it controls whether the option is demanded;
 this is useful when using `.options()` to specify command line parameters.
 
-A combination of `.demand(1)` and `.strict()` will allow you to require a user to pass at least one command:
-
-```js
-var argv = require('yargs')
-  .command('install', 'tis a mighty fine package to install')
-  .demand(1)
-  .strict()
+```javascript
+// demand individual options within the option constructor
+require('yargs')
+  .options({
+    'run': {
+      alias: 'r',
+      describe: 'run your program',
+      demand: true
+    },
+    'path': {
+      alias: 'p',
+      describe: 'provide a path to file',
+      demand: true
+    },
+    'spec': {
+      alias: 's',
+      describe: 'program specifications'
+    }
+  })
+  .help()
   .argv
 ```
+which will provide the following output:
+```bash
+Options:
+  --run, -r   run your program                                       [required]
+  --path, -p  provide a path to file                                 [required]
+  --spec, -s  program specifications
+  --help      Show help                                               [boolean]
 
-Similarly, you can require a command and arguments at the same time:
+Missing required arguments: run, path
+```
 
-```js
-var argv = require('yargs')
-  .command('install', 'tis a mighty fine package to install')
-  .demand(1, ['w', 'm'])
-  .strict()
+<a name="demandCommand"></a>.demandCommand(min, [minMsg])
+------------------------------
+.demandCommand(min, [max], [minMsg], [maxMsg])
+------------------------------
+
+Demand in context of commands. You can demand a minimum and a maximum number a user can have within your program, as well as provide corresponding error messages if either of the demands is not met.
+```javascript
+require('yargs')
+  .command({
+    command: 'configure <key> [value]',
+    aliases: ['config', 'cfg'],
+    desc: 'Set a config variable',
+    builder: (yargs) => yargs.default('value', 'true'),
+    handler: (argv) => {
+      console.log(`setting ${argv.key} to ${argv.value}`)
+    }
+  })
+  // provide a minimum demand and a minimum demand message
+  .demandCommand(1, 'You need at least one command before moving on')
+  .help()
   .argv
 ```
+which will provide the following output:
+```bash
+Commands:
+  configure <key> [value]  Set a config variable         [aliases: config, cfg]
+
+Options:
+  --help  Show help                                                   [boolean]
+
+You need at least one command before moving on
+```
+
+_Note: in `minMsg` and `maxMsg`, every occurrence of `$0` will be replaced
+with the observed value, and every instance of `$1` will be replaced with the
+expected value._
 
 <a name="describe"></a>.describe(key, desc)
 --------------------
@@ -1150,15 +1254,17 @@ yargs have been validated.
 
 Method to execute when a failure occurs, rather than printing the failure message.
 
-`fn` is called with the failure message that would have been printed and the
-`Error` instance originally thrown, if any.
+`fn` is called with the failure message that would have been printed, the
+`Error` instance originally thrown and yargs state when the failure
+occured.
 
 ```js
 var argv = require('yargs')
-  .fail(function (msg, err) {
+  .fail(function (msg, err, yargs) {
     if (err) throw err // preserve stack
     console.error('You broke it!')
     console.error(msg)
+    console.error('You should be doing', yargs.help())
     process.exit(1)
   })
   .argv
@@ -1416,7 +1522,7 @@ var argv = require('yargs')
 
 This method can be used to make yargs aware of options that _could_
 exist. You can also pass an `opt` object which can hold further
-customization, like `.alias()`, `.demand()` etc. for that option.
+customization, like `.alias()`, `.demandOption()` etc. for that option.
 
 For example:
 
@@ -1438,7 +1544,7 @@ is the same as
 ````javascript
 var argv = require('yargs')
     .alias('f', 'file')
-    .demand('f')
+    .demandOption('f')
     .default('f', '/etc/passwd')
     .describe('f', 'x marks the spot')
     .string('f')
@@ -1475,7 +1581,7 @@ Valid `opt` keys include:
 - `count`: boolean, interpret option as a count of boolean flags, see [`count()`](#count)
 - `default`: value, set a default value for the option, see [`default()`](#default)
 - `defaultDescription`: string, use this description for the default value in help content, see [`default()`](#default)
-- `demand`/`require`/`required`: boolean or string, demand the option be given, with optional error message, see [`demand()`](#demand)
+- `demandOption`: boolean or string, demand the option be given, with optional error message, see [`demandOption()`](#demandOption)
 - `desc`/`describe`/`description`: string, the option description for help content, see [`describe()`](#describe)
 - `global`: boolean, indicate that this key should not be [reset](#reset) when a command is invoked, see [`global()`](#global)
 - `group`: string, when displaying usage instructions place the option under an alternative group heading, see [`group()`](#group)
@@ -1577,7 +1683,7 @@ var yargs = require('yargs')
   .usage('$0 command')
   .command('hello', 'hello command')
   .command('world', 'world command')
-  .demand(1, 'must provide a valid command'),
+  .demandCommand(1, 'must provide a valid command'),
   argv = yargs.argv,
   command = argv._[0];
 
@@ -1644,7 +1750,7 @@ line_count.js:
 #!/usr/bin/env node
 var argv = require('yargs')
     .usage('Count the lines in a file.\nUsage: $0 -f <file>')
-    .demand('f')
+    .demandOption('f')
     .alias('f', 'file')
     .describe('f', 'Load a file')
     .string('f')

package/lib/command.js

@@ -96,7 +96,7 @@ module.exports = function (yargs, usage, validation) {
 
   function parseCommand (cmd) {
     var extraSpacesStrippedCommand = cmd.replace(/\s{2,}/g, ' ')
-    var splitCommand = extraSpacesStrippedCommand.split(/\s/)
+    var splitCommand = extraSpacesStrippedCommand.split(/\s+(?![^[]*]|[^<]*>)/)
     var bregex = /\.*[\][<>]/g
     var parsedCommand = {
       cmd: (splitCommand.shift()).replace(bregex, ''),
@@ -105,15 +105,16 @@ module.exports = function (yargs, usage, validation) {
     }
     splitCommand.forEach(function (cmd, i) {
       var variadic = false
+      cmd = cmd.replace(/\s/g, '')
       if (/\.+[\]>]/.test(cmd) && i === splitCommand.length - 1) variadic = true
       if (/^\[/.test(cmd)) {
         parsedCommand.optional.push({
-          cmd: cmd.replace(bregex, ''),
+          cmd: cmd.replace(bregex, '').split('|'),
           variadic: variadic
         })
       } else {
         parsedCommand.demanded.push({
-          cmd: cmd.replace(bregex, ''),
+          cmd: cmd.replace(bregex, '').split('|'),
           variadic: variadic
         })
       }
@@ -163,7 +164,7 @@ module.exports = function (yargs, usage, validation) {
       })
       innerArgv = innerArgv.argv
     }
-    if (!yargs._hasOutput()) populatePositional(commandHandler, innerArgv, currentContext, yargs)
+    if (!yargs._hasOutput()) populatePositionals(commandHandler, innerArgv, currentContext, yargs)
 
     if (commandHandler.handler && !yargs._hasOutput()) {
       commandHandler.handler(innerArgv)
@@ -174,7 +175,9 @@ module.exports = function (yargs, usage, validation) {
     return innerArgv
   }
 
-  function populatePositional (commandHandler, argv, context, yargs) {
+  // transcribe all positional arguments "command <foo> <bar> [apple]"
+  // onto argv.
+  function populatePositionals (commandHandler, argv, context, yargs) {
     argv._ = argv._.slice(context.commands.length) // nuke the current commands
     var demanded = commandHandler.demanded.slice(0)
     var optional = commandHandler.optional.slice(0)
@@ -183,27 +186,39 @@ module.exports = function (yargs, usage, validation) {
 
     while (demanded.length) {
       var demand = demanded.shift()
-      if (demand.variadic) argv[demand.cmd] = []
-      if (!argv._.length) break
-      if (demand.variadic) argv[demand.cmd] = argv._.splice(0)
-      else argv[demand.cmd] = argv._.shift()
-      postProcessPositional(yargs, argv, demand.cmd)
-      addCamelCaseExpansions(argv, demand.cmd)
+      populatePositional(demand, argv, yargs)
     }
 
     while (optional.length) {
       var maybe = optional.shift()
-      if (maybe.variadic) argv[maybe.cmd] = []
-      if (!argv._.length) break
-      if (maybe.variadic) argv[maybe.cmd] = argv._.splice(0)
-      else argv[maybe.cmd] = argv._.shift()
-      postProcessPositional(yargs, argv, maybe.cmd)
-      addCamelCaseExpansions(argv, maybe.cmd)
+      populatePositional(maybe, argv, yargs)
     }
 
     argv._ = context.commands.concat(argv._)
   }
 
+  // populate a single positional argument and its
+  // aliases onto argv.
+  function populatePositional (positional, argv, yargs) {
+    // "positional" consists of the positional.cmd, an array representing
+    // the positional's name and aliases, and positional.variadic
+    // indicating whether or not it is a variadic array.
+    var variadics = null
+    var value = null
+    for (var i = 0, cmd; (cmd = positional.cmd[i]) !== undefined; i++) {
+      if (positional.variadic) {
+        if (variadics) argv[cmd] = variadics.slice(0)
+        else argv[cmd] = variadics = argv._.splice(0)
+      } else {
+        if (!value && !argv._.length) continue
+        if (value) argv[cmd] = value
+        else argv[cmd] = value = argv._.shift()
+      }
+      postProcessPositional(yargs, argv, cmd)
+      addCamelCaseExpansions(argv, cmd)
+    }
+  }
+
   // TODO move positional arg logic to yargs-parser and remove this duplication
   function postProcessPositional (yargs, argv, key) {
     var coerce = yargs.getOptions().coerce[key]

package/lib/usage.js

@@ -34,7 +34,7 @@ module.exports = function (yargs, y18n) {
 
     if (fails.length) {
       for (var i = fails.length - 1; i >= 0; --i) {
-        fails[i](msg, err)
+        fails[i](msg, err, self)
       }
     } else {
       if (yargs.getExitProcess()) setBlocking(true)
@@ -110,12 +110,11 @@ module.exports = function (yargs, y18n) {
   }
 
   function getWrap () {
-    // lazily call windowWidth() because it's very expensive,
-    // and only needs to be called if the user wants to show usage/help
     if (!wrapSet) {
       wrap = windowWidth()
       wrapSet = true
     }
+
     return wrap
   }
 
@@ -128,18 +127,22 @@ module.exports = function (yargs, y18n) {
   self.help = function () {
     normalizeAliases()
 
-    var demanded = yargs.getDemanded()
+    // handle old demanded API
+    var demandedOptions = yargs.getDemandedOptions()
+    var demandedCommands = yargs.getDemandedCommands()
     var groups = yargs.getGroups()
     var options = yargs.getOptions()
     var keys = Object.keys(
       Object.keys(descriptions)
-      .concat(Object.keys(demanded))
+      .concat(Object.keys(demandedOptions))
+      .concat(Object.keys(demandedCommands))
       .concat(Object.keys(options.default))
       .reduce(function (acc, key) {
         if (key !== '_') acc[key] = true
         return acc
       }, {})
     )
+
     var theWrap = getWrap()
     var ui = require('cliui')({
       width: theWrap,
@@ -231,7 +234,7 @@ module.exports = function (yargs, y18n) {
 
         var extra = [
           type,
-          demanded[key] ? '[' + __('required') + ']' : null,
+          demandedOptions[key] ? '[' + __('required') + ']' : null,
           options.choices && options.choices[key] ? '[' + __('choices:') + ' ' +
             self.stringifiedValues(options.choices[key]) + ']' : null,
           defaultString(options.default[key], options.defaultDescription[key])
@@ -303,7 +306,8 @@ module.exports = function (yargs, y18n) {
   // make sure any options set for aliases,
   // are copied to the keys being aliased.
   function normalizeAliases () {
-    var demanded = yargs.getDemanded()
+    // handle old demanded API
+    var demandedOptions = yargs.getDemandedOptions()
     var options = yargs.getOptions()
 
     ;(Object.keys(options.alias) || []).forEach(function (key) {
@@ -311,7 +315,7 @@ module.exports = function (yargs, y18n) {
         // copy descriptions.
         if (descriptions[alias]) self.describe(key, descriptions[alias])
         // copy demanded.
-        if (demanded[alias]) yargs.demand(key, demanded[alias].msg)
+        if (demandedOptions[alias]) yargs.demandOption(key, demandedOptions[alias].msg)
         // type messages.
         if (~options.boolean.indexOf(alias)) yargs.boolean(key)
         if (~options.count.indexOf(alias)) yargs.count(key)
@@ -397,8 +401,12 @@ module.exports = function (yargs, y18n) {
 
   // guess the width of the console window, max-width 80.
   function windowWidth () {
-    const wsize = require('window-size')
-    return wsize.width ? Math.min(80, wsize.width) : null
+    var maxWidth = 80
+    if (typeof process === 'object' && process.stdout && process.stdout.columns) {
+      return Math.min(maxWidth, process.stdout.columns)
+    } else {
+      return maxWidth
+    }
   }
 
   // logic for displaying application version.

package/lib/validation.js

@@ -10,21 +10,33 @@ module.exports = function (yargs, usage, y18n) {
   // validate appropriate # of non-option
   // arguments were provided, i.e., '_'.
   self.nonOptionCount = function (argv) {
-    const demanded = yargs.getDemanded()
+    const demandedCommands = yargs.getDemandedCommands()
     // don't count currently executing commands
     const _s = argv._.length - yargs.getContext().commands.length
 
-    if (demanded._ && (_s < demanded._.count || _s > demanded._.max)) {
-      if (demanded._.msg !== undefined) {
-        usage.fail(demanded._.msg)
-      } else if (_s < demanded._.count) {
-        usage.fail(
-          __('Not enough non-option arguments: got %s, need at least %s', _s, demanded._.count)
-        )
-      } else {
-        usage.fail(
-          __('Too many non-option arguments: got %s, maximum of %s', _s, demanded._.max)
-        )
+    if (demandedCommands._ && (_s < demandedCommands._.min || _s > demandedCommands._.max)) {
+      if (_s < demandedCommands._.min) {
+        if (demandedCommands._.minMsg !== undefined) {
+          usage.fail(
+            // replace $0 with observed, $1 with expected.
+            demandedCommands._.minMsg ? demandedCommands._.minMsg.replace(/\$0/g, _s).replace(/\$1/, demandedCommands._.min) : null
+          )
+        } else {
+          usage.fail(
+            __('Not enough non-option arguments: got %s, need at least %s', _s, demandedCommands._.min)
+          )
+        }
+      } else if (_s > demandedCommands._.max) {
+        if (demandedCommands._.maxMsg !== undefined) {
+          usage.fail(
+            // replace $0 with observed, $1 with expected.
+            demandedCommands._.maxMsg ? demandedCommands._.maxMsg.replace(/\$0/g, _s).replace(/\$1/, demandedCommands._.max) : null
+          )
+        } else {
+          usage.fail(
+          __('Too many non-option arguments: got %s, maximum of %s', _s, demandedCommands._.max)
+          )
+        }
       }
     }
   }
@@ -73,13 +85,13 @@ module.exports = function (yargs, usage, y18n) {
 
   // make sure all the required arguments are present.
   self.requiredArguments = function (argv) {
-    const demanded = yargs.getDemanded()
+    const demandedOptions = yargs.getDemandedOptions()
     var missing = null
 
-    Object.keys(demanded).forEach(function (key) {
+    Object.keys(demandedOptions).forEach(function (key) {
       if (!argv.hasOwnProperty(key)) {
         missing = missing || {}
-        missing[key] = demanded[key]
+        missing[key] = demandedOptions[key]
       }
     })
 
@@ -107,7 +119,7 @@ module.exports = function (yargs, usage, y18n) {
   self.unknownArguments = function (argv, aliases) {
     const aliasLookup = {}
     const descriptions = usage.getDescriptions()
-    const demanded = yargs.getDemanded()
+    const demandedOptions = yargs.getDemandedOptions()
     const commandKeys = yargs.getCommandInstance().getCommands()
     const unknown = []
     const currentContext = yargs.getContext()
@@ -121,7 +133,7 @@ module.exports = function (yargs, usage, y18n) {
     Object.keys(argv).forEach(function (key) {
       if (key !== '$0' && key !== '_' &&
         !descriptions.hasOwnProperty(key) &&
-        !demanded.hasOwnProperty(key) &&
+        !demandedOptions.hasOwnProperty(key) &&
         !aliasLookup.hasOwnProperty(key)) {
         unknown.push(key)
       }
@@ -223,12 +235,6 @@ module.exports = function (yargs, usage, y18n) {
     const implyFail = []
 
     Object.keys(implied).forEach(function (key) {
-      var booleanNegation
-      if (yargs.getOptions().configuration['boolean-negation'] === false) {
-        booleanNegation = false
-      } else {
-        booleanNegation = true
-      }
       var num
       const origKey = key
       var value = implied[key]
@@ -240,7 +246,7 @@ module.exports = function (yargs, usage, y18n) {
       if (typeof key === 'number') {
         // check length of argv._
         key = argv._.length >= key
-      } else if (key.match(/^--no-.+/) && booleanNegation) {
+      } else if (key.match(/^--no-.+/)) {
         // check if key doesn't exist
         key = key.match(/^--no-(.+)/)[1]
         key = !argv[key]
@@ -254,7 +260,7 @@ module.exports = function (yargs, usage, y18n) {
 
       if (typeof value === 'number') {
         value = argv._.length >= value
-      } else if (value.match(/^--no-.+/) && booleanNegation) {
+      } else if (value.match(/^--no-.+/)) {
         value = value.match(/^--no-(.+)/)[1]
         value = !argv[value]
       } else {
@@ -277,6 +283,30 @@ module.exports = function (yargs, usage, y18n) {
     }
   }
 
+  var conflicting = {}
+  self.conflicts = function (key, value) {
+    if (typeof key === 'object') {
+      Object.keys(key).forEach(function (k) {
+        self.conflicts(k, key[k])
+      })
+    } else {
+      conflicting[key] = value
+    }
+  }
+  self.getConflicting = function () {
+    return conflicting
+  }
+
+  self.conflicting = function (argv) {
+    var args = Object.getOwnPropertyNames(argv)
+
+    args.forEach(function (arg) {
+      if (conflicting[arg] && args.indexOf(conflicting[arg]) !== -1) {
+        usage.fail(__('Arguments %s and %s are mutually exclusive', arg, conflicting[arg]))
+      }
+    })
+  }
+
   self.recommendCommands = function (cmd, potentialCommands) {
     const distance = require('./levenshtein')
     const threshold = 3 // if it takes more than three edits, let's move on.
@@ -299,6 +329,7 @@ module.exports = function (yargs, usage, y18n) {
       return globalLookup[k]
     })
     checks = []
+    conflicting = {}
     return self
   }
 
@@ -307,10 +338,12 @@ module.exports = function (yargs, usage, y18n) {
     frozen = {}
     frozen.implied = implied
     frozen.checks = checks
+    frozen.conflicting = conflicting
   }
   self.unfreeze = function () {
     implied = frozen.implied
     checks = frozen.checks
+    conflicting = frozen.conflicting
     frozen = undefined
   }
 

package/locales/be.json

@@ -0,0 +1,39 @@
+{
+  "Commands:": "Каманды:",
+  "Options:": "Опцыі:",
+  "Examples:": "Прыклады:",
+  "boolean": "булевы тып",
+  "count": "падлік",
+  "string": "радковы тып",
+  "number": "лік",
+  "array": "масіў",
+  "required": "неабходна",
+  "default:": "па змаўчанні:",
+  "choices:": "магчымасці:",
+  "aliases:": "аліасы:",
+  "generated-value": "згенераванае значэнне",
+  "Not enough non-option arguments: got %s, need at least %s": "Недастаткова неапцыйных аргументаў: ёсць %s, трэба як мінімум %s",
+  "Too many non-option arguments: got %s, maximum of %s": "Занадта шмат неапцыйных аргументаў: ёсць %s, максімум дапушчальна %s",
+  "Missing argument value: %s": {
+    "one": "Не хапае значэння аргументу: %s",
+    "other": "Не хапае значэнняў аргументаў: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Не хапае неабходнага аргументу: %s",
+    "other": "Не хапае неабходных аргументаў: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Невядомы аргумент: %s",
+    "other": "Невядомыя аргументы: %s"
+  },
+  "Invalid values:": "Несапраўдныя значэння:",
+  "Argument: %s, Given: %s, Choices: %s": "Аргумент: %s, Дадзенае значэнне: %s, Магчымасці: %s",
+  "Argument check failed: %s": "Праверка аргументаў не ўдалася: %s",
+  "Implications failed:": "Дадзены аргумент патрабуе наступны дадатковы аргумент:",
+  "Not enough arguments following: %s": "Недастаткова наступных аргументаў: %s",
+  "Invalid JSON config file: %s": "Несапраўдны файл канфігурацыі JSON: %s",
+  "Path to JSON config file": "Шлях да файла канфігурацыі JSON",
+  "Show help": "Паказаць дапамогу",
+  "Show version number": "Паказаць нумар версіі",
+  "Did you mean %s?": "Вы мелі на ўвазе %s?"
+}

package/locales/en.json

@@ -35,5 +35,6 @@
   "Path to JSON config file": "Path to JSON config file",
   "Show help": "Show help",
   "Show version number": "Show version number",
-  "Did you mean %s?": "Did you mean %s?"
+  "Did you mean %s?": "Did you mean %s?",
+  "Arguments %s and %s are mutually exclusive" : "Arguments %s and %s are mutually exclusive"
 }

package/locales/nl.json

@@ -0,0 +1,39 @@
+{
+  "Commands:": "Opdrachten:",
+  "Options:": "Opties:",
+  "Examples:": "Voorbeelden:",
+  "boolean": "boolean",
+  "count": "aantal",
+  "string": "text",
+  "number": "nummer",
+  "array": "lijst",
+  "required": "verplicht",
+  "default:": "standaard:",
+  "choices:": "keuzes:",
+  "aliases:": "aliassen:",
+  "generated-value": "gegenereerde waarde",
+  "Not enough non-option arguments: got %s, need at least %s": "Niet genoeg non-optie argumenten. Gekregen: %s, minstens nodig: %s",
+  "Too many non-option arguments: got %s, maximum of %s": "Te veel non-optie argumenten. Gekregen: %s, maximum: %s",
+  "Missing argument value: %s": {
+    "one": "Missing argument value: %s",
+    "other": "Missing argument values: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Missend verplichte argument: %s",
+    "other": "Missende verplichte argumenten: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Onbekend argument: %s",
+    "other": "Onbekende argumenten: %s"
+  },
+  "Invalid values:": "Ongeldige waardes:",
+  "Argument: %s, Given: %s, Choices: %s": "Argument: %s, Gegeven: %s, Keuzes: %s",
+  "Argument check failed: %s": "Argument check mislukt: %s",
+  "Implications failed:": "Implicaties mislukt:",
+  "Not enough arguments following: %s": "Niet genoeg argumenten na: %s",
+  "Invalid JSON config file: %s": "Ongeldig JSON configuratiebestand: %s",
+  "Path to JSON config file": "Pad naar JSON configuratiebestand",
+  "Show help": "Toon help",
+  "Show version number": "Toon versie nummer",
+  "Did you mean %s?": "Bedoelde u misschien %s?"
+}

package/locales/pt.json

@@ -33,5 +33,6 @@
   "Invalid JSON config file: %s": "Arquivo de configuração em JSON esta inválido: %s",
   "Path to JSON config file": "Caminho para o arquivo de configuração em JSON",
   "Show help": "Mostra ajuda",
-  "Show version number": "Mostra número de versão"
+  "Show version number": "Mostra número de versão",
+  "Arguments %s and %s are mutually exclusive" : "Argumentos %s e %s são mutualmente exclusivos"
 }

package/locales/pt_BR.json

@@ -35,5 +35,6 @@
   "Path to JSON config file": "Caminho para o arquivo JSON de configuração",
   "Show help": "Exibe ajuda",
   "Show version number": "Exibe a versão",
-  "Did you mean %s?": "Você quis dizer %s?"
+  "Did you mean %s?": "Você quis dizer %s?",
+  "Arguments %s and %s are mutually exclusive" : "Argumentos %s e %s são mutualmente exclusivos"
 }

package/locales/ru.json

@@ -1,5 +1,5 @@
 {
-  "Commands:": "Комманды:",
+  "Commands:": "Команды:",
   "Options:": "Опции:",
   "Examples:": "Примеры:",
   "boolean": "булевый тип",
@@ -12,7 +12,7 @@
   "choices:": "возможности:",
   "aliases:": "алиасы:",
   "generated-value": "генерированное значение",
-  "Not enough non-option arguments: got %s, need at least %s": "Не достаточно неопционных аргументов: есть %s, нужно как минимум %s",
+  "Not enough non-option arguments: got %s, need at least %s": "Недостаточно неопционных аргументов: есть %s, нужно как минимум %s",
   "Too many non-option arguments: got %s, maximum of %s": "Слишком много неопционных аргументов: есть %s, максимум допустимо %s",
   "Missing argument value: %s": {
     "one": "Не хватает значения аргумента: %s",
@@ -30,7 +30,7 @@
   "Argument: %s, Given: %s, Choices: %s": "Аргумент: %s, Данное значение: %s, Возможности: %s",
   "Argument check failed: %s": "Проверка аргументов не удалась: %s",
   "Implications failed:": "Данный аргумент требует следующий дополнительный аргумент:",
-  "Not enough arguments following: %s": "Not enough arguments following: %s",
+  "Not enough arguments following: %s": "Недостаточно следующих аргументов: %s",
   "Invalid JSON config file: %s": "Недействительный файл конфигурации JSON: %s",
   "Path to JSON config file": "Путь к файлу конфигурации JSON",
   "Show help": "Показать помощь",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yargs",
-  "version": "6.3.0",
+  "version": "6.6.0",
   "description": "yargs the modern, pirate-themed, successor to optimist.",
   "main": "./index.js",
   "files": [
@@ -23,22 +23,21 @@
     "set-blocking": "^2.0.0",
     "string-width": "^1.0.2",
     "which-module": "^1.0.0",
-    "window-size": "^0.2.0",
     "y18n": "^3.2.1",
-    "yargs-parser": "^4.0.2"
+    "yargs-parser": "^4.2.0"
   },
   "devDependencies": {
     "chai": "^3.4.1",
     "chalk": "^1.1.3",
     "coveralls": "^2.11.11",
     "cpr": "^2.0.0",
-    "cross-spawn": "^4.0.0",
+    "cross-spawn": "^5.0.1",
     "es6-promise": "^4.0.2",
     "hashish": "0.0.4",
     "mocha": "^3.0.1",
-    "nyc": "^8.3.2",
+    "nyc": "^10.0.0",
     "rimraf": "^2.5.0",
-    "standard": "^8.2.0",
+    "standard": "^8.6.0",
     "standard-version": "^3.0.0",
     "which": "^1.2.9"
   },
@@ -74,7 +73,8 @@
   "greenkeeper": {
     "ignore": [
       "string-width",
-      "read-pkg-up"
+      "read-pkg-up",
+      "camelcase"
     ]
   }
 }

package/yargs.js

@@ -98,7 +98,7 @@ function Yargs (processArgs, cwd, parentRequire) {
 
     var objectOptions = [
       'narg', 'key', 'alias', 'default', 'defaultDescription',
-      'config', 'choices', 'demanded', 'coerce'
+      'config', 'choices', 'demandedOptions', 'demandedCommands', 'coerce'
     ]
 
     arrayOptions.forEach(function (k) {
@@ -301,14 +301,15 @@ function Yargs (processArgs, cwd, parentRequire) {
     return self
   }
 
+  // deprecated: the demand API is too overloaded, and is being
+  // deprecated in favor of .demandCommand() .demandOption().
   self.demand = self.required = self.require = function (keys, max, msg) {
     // you can optionally provide a 'max' key,
     // which will raise an exception if too many '_'
     // options are provided.
-
     if (Array.isArray(max)) {
       max.forEach(function (key) {
-        self.demand(key, msg)
+        self.demandOption(key, msg)
       })
       max = Infinity
     } else if (typeof max !== 'number') {
@@ -317,26 +318,61 @@ function Yargs (processArgs, cwd, parentRequire) {
     }
 
     if (typeof keys === 'number') {
-      if (!options.demanded._) options.demanded._ = { count: 0, msg: null, max: max }
-      options.demanded._.count = keys
-      options.demanded._.msg = msg
+      self.demandCommand(keys, max, msg)
     } else if (Array.isArray(keys)) {
       keys.forEach(function (key) {
-        self.demand(key, msg)
+        self.demandOption(key, msg)
       })
     } else {
       if (typeof msg === 'string') {
-        options.demanded[keys] = { msg: msg }
+        self.demandOption(keys, msg)
       } else if (msg === true || typeof msg === 'undefined') {
-        options.demanded[keys] = { msg: undefined }
+        self.demandOption(keys)
       }
     }
 
     return self
   }
 
-  self.getDemanded = function () {
-    return options.demanded
+  self.demandOption = function (key, msg) {
+    if (Array.isArray(key)) {
+      key.forEach(function (key) {
+        self.demandOption(key, msg)
+      })
+    } else {
+      if (typeof msg === 'string') {
+        options.demandedOptions[key] = { msg: msg }
+      // allow edge-case of options: {a: {demand: true}, b: {demand: false}}
+      } else if (msg === true || typeof msg === 'undefined') {
+        options.demandedOptions[key] = { msg: undefined }
+      }
+    }
+
+    return self
+  }
+
+  self.demandCommand = function (min, max, minMsg, maxMsg) {
+    if (typeof max !== 'number') {
+      minMsg = max
+      max = Infinity
+    }
+
+    options.demandedCommands._ = {
+      min: min,
+      max: max,
+      minMsg: minMsg,
+      maxMsg: maxMsg
+    }
+
+    return self
+  }
+
+  self.getDemandedOptions = function () {
+    return options.demandedOptions
+  }
+
+  self.getDemandedCommands = function () {
+    return options.demandedCommands
   }
 
   self.requiresArg = function (requiresArgs) {
@@ -354,6 +390,11 @@ function Yargs (processArgs, cwd, parentRequire) {
     return self
   }
 
+  self.conflicts = function (key1, key2) {
+    validation.conflicts(key1, key2)
+    return self
+  }
+
   self.usage = function (msg, opts) {
     if (!opts && typeof msg === 'object') {
       opts = msg
@@ -383,7 +424,13 @@ function Yargs (processArgs, cwd, parentRequire) {
   }
 
   self.describe = function (key, desc) {
-    options.key[key] = true
+    if (typeof key === 'object') {
+      Object.keys(key).forEach(function (k) {
+        options.key[k] = true
+      })
+    } else {
+      options.key[key] = true
+    }
     usage.describe(key, desc)
     return self
   }
@@ -416,7 +463,8 @@ function Yargs (processArgs, cwd, parentRequire) {
     var obj = {}
     try {
       obj = readPkgUp.sync({
-        cwd: path || require('require-main-filename')(parentRequire || require)
+        cwd: path || require('require-main-filename')(parentRequire || require),
+        normalize: false
       })
     } catch (noop) {}
 
@@ -445,16 +493,12 @@ function Yargs (processArgs, cwd, parentRequire) {
     // skipping validation, etc.
     if (!shortCircuit) processArgs = args
 
-    if (parseFn) {
-      freeze()
-      exitProcess = false
-    }
+    freeze()
+    if (parseFn) exitProcess = false
 
     var parsed = parseArgs(args, shortCircuit)
-    if (parseFn) {
-      parseFn(exitError, parsed, output)
-      unfreeze()
-    }
+    if (parseFn) parseFn(exitError, parsed, output)
+    unfreeze()
 
     return parsed
   }
@@ -483,6 +527,10 @@ function Yargs (processArgs, cwd, parentRequire) {
         self.demand(key, demand)
       }
 
+      if ('demandOption' in opt) {
+        self.demandOption(key, opt.demandOption)
+      }
+
       if ('config' in opt) {
         self.config(key, opt.configParser)
       }
@@ -801,7 +849,7 @@ function Yargs (processArgs, cwd, parentRequire) {
   }
 
   self.terminalWidth = function () {
-    return require('window-size').width
+    return process.stdout.columns
   }
 
   Object.defineProperty(self, 'argv', {
@@ -821,7 +869,7 @@ function Yargs (processArgs, cwd, parentRequire) {
 
   function parseArgs (args, shortCircuit) {
     options.__ = y18n.__
-    options.configuration = pkgUp(cwd)['yargs'] || {}
+    options.configuration = pkgUp()['yargs'] || {}
     const parsed = Parser.detailed(args, options)
     var argv = parsed.argv
     if (parseContext) argv = assign(parseContext, argv)
@@ -949,6 +997,7 @@ function Yargs (processArgs, cwd, parentRequire) {
         validation.customChecks(argv, aliases)
         validation.limitedChoices(argv)
         validation.implications(argv)
+        validation.conflicting(argv)
       }
     }