yargs 3.28.0 → 3.32.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## Change Log
 
+### v3.32.0 (2016/1/14 10:13 +07:00)
+
+- [#344](https://github.com/bcoe/yargs/pull/344) yargs now has a code of conduct and contributor guidelines (@bcoe)
+- [#341](https://github.com/bcoe/yargs/issues/341) Fix edge-case with camel-case arguments (@davibe)
+- [#331](https://github.com/bcoe/yargs/pull/331) Handle parsing a raw argument string (@kellyselden)
+- [#325](https://github.com/bcoe/yargs/pull/325) Tweaks to make tests pass again on Windows (@isaacs)
+- [#321](https://github.com/bcoe/yargs/pull/321) Custom config parsing function (@bcoe)
+
+### v3.31.0 (2015/12/03 10:15 +07:00)
+
+- [#239](https://github.com/bcoe/yargs/pull/239) Pass argv to commands (@bcoe)
+- [#308](https://github.com/bcoe/yargs/pull/308) Yargs now handles environment variables (@nexdrew)
+- [#302](https://github.com/bcoe/yargs/pull/302) Add Indonesian translation (@rilut)
+- [#300](https://github.com/bcoe/yargs/pull/300) Add Turkish translation (@feyzo)
+- [#298](https://github.com/bcoe/yargs/pull/298) Add Norwegian Bokmål translation (@sindresorhus)
+- [#297](https://github.com/bcoe/yargs/pull/297) Fix for layout of cjk characters (@disjukr)
+- [#296](https://github.com/bcoe/yargs/pull/296) Add Korean translation (@disjukr)
+
+### v3.30.0 (2015/11/13 16:29 +07:00)
+
+- [#293](https://github.com/bcoe/yargs/pull/293) Polish language support (@kamilogorek)
+- [#291](https://github.com/bcoe/yargs/pull/291) fix edge-cases with `.alias()` (@bcoe)
+- [#289](https://github.com/bcoe/yargs/pull/289) group options in custom groups (@bcoe)
+
+### v3.29.0 (2015/10/16 21:51 +07:00)
+
+- [#282](https://github.com/bcoe/yargs/pull/282) completions now accept promises (@LinusU)
+- [#281](https://github.com/bcoe/yargs/pull/281) fix parsing issues with dot notation (@bcoe)
+
 ### v3.28.0 (2015/10/16 1:55 +07:00)
 
 - [#277](https://github.com/bcoe/yargs/pull/277) adds support for ansi escape codes (@bcoe)

package/README.md

@@ -463,8 +463,14 @@ Hidden commands don't show up in the help output and aren't available for
 completion.
 
 Optionally, you can provide a handler `fn` which will be executed when
-a given command is provided. The handler will be executed with an instance
-of `yargs`, which can be used to compose nested commands.
+a given command is provided. The handler will be called with `yargs` and
+`argv` as arguments.
+
+`yargs` is a blank instance of yargs, which can be used to compose a nested
+hierarchy of options handlers.
+
+`argv` represents the arguments parsed prior to the
+command being executed (those described in the outer yargs instance).
 
 Here's an example of top-level and nested commands in action:
 
@@ -472,7 +478,7 @@ Here's an example of top-level and nested commands in action:
 var argv = require('yargs')
   .usage('npm <command>')
   .command('install', 'tis a mighty fine package to install')
-  .command('publish', 'shiver me timbers, should you be sharing all that', function (yargs) {
+  .command('publish', 'shiver me timbers, should you be sharing all that', function (yargs, argv) {
     argv = yargs.option('f', {
       alias: 'force',
       description: 'yar, it usually be a bad idea'
@@ -514,7 +520,7 @@ var argv = require('yargs')
   .argv;
 ```
 
-But wait, there's more! You can provide asynchronous completions.
+You can also provide asynchronous completions.
 
 ```js
 var argv = require('yargs')
@@ -529,15 +535,42 @@ var argv = require('yargs')
   .argv;
 ```
 
-<a name="config"></a>.config(key, [description])
+But wait, there's more! You can return an asynchronous promise.
+
+```js
+var argv = require('yargs')
+  .completion('completion', function(current, argv, done) {
+    return new Promise(function (resolve, reject) {
+      setTimeout(function () {
+        resolve(['apple', 'banana'])
+      }, 10)
+    })
+  })
+  .argv;
+```
+
+<a name="config"></a>.config(key, [description], [parseFn])
 ------------
 
 Tells the parser that if the option specified by `key` is passed in, it
 should be interpreted as a path to a JSON config file. The file is loaded
-and parsed, and its properties are set as arguments. If present, the
-`description` parameter customizes the description of the config (`key`) option
+and parsed, and its properties are set as arguments.
+
+An optional `description` can be provided to customize the config (`key`) option
 in the usage string.
 
+An optional `parseFn` can be used to provide a custom parser. The parsing
+function must be synchronous, and should return an object containing
+key value pairs or an error.
+
+```js
+var argv = require('yargs')
+  .config('settings', function (configPath) {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+  })
+  .argv
+```
+
 <a name="count"></a>.count(key)
 ------------
 
@@ -600,6 +633,63 @@ Optionally `.describe()` can take an object that maps keys to descriptions.
 
 Should yargs attempt to detect the os' locale? Defaults to `true`.
 
+.env([prefix])
+--------------
+
+Tell yargs to parse environment variables matching the given prefix and apply
+them to argv as though they were command line arguments.
+
+If this method is called with no argument or with an empty string or with `true`,
+then all env vars will be applied to argv.
+
+Program arguments are defined in this order of precedence:
+
+1. Command line args
+2. Config file
+3. Env var
+4. Configured defaults
+
+```js
+var argv = require('yargs')
+  .env('MY_PROGRAM')
+  .option('f', {
+    alias: 'fruit-thing',
+    default: 'apple'
+  })
+  .argv
+console.log(argv)
+```
+
+```
+$ node fruity.js
+{ _: [],
+  f: 'apple',
+  'fruit-thing': 'apple',
+  fruitThing: 'apple',
+  '$0': 'fruity.js' }
+```
+
+```
+$ MY_PROGRAM_FRUIT_THING=banana node fruity.js
+{ _: [],
+  fruitThing: 'banana',
+  f: 'banana',
+  'fruit-thing': 'banana',
+  '$0': 'fruity.js' }
+```
+
+```
+$ MY_PROGRAM_FRUIT_THING=banana node fruity.js -f cat
+{ _: [],
+  f: 'cat',
+  'fruit-thing': 'cat',
+  fruitThing: 'cat',
+  '$0': 'fruity.js' }
+```
+
+Env var parsing is disabled by default, but you can also explicitly disable it
+by calling `.env(false)`, e.g. if you need to undo previous configuration.
+
 .epilog(str)
 ------------
 .epilogue(str)
@@ -635,6 +725,27 @@ Method to execute when a failure occurs, rather than printing the failure messag
 
 `fn` is called with the failure message that would have been printed.
 
+<a name="group"></a>.group(key(s), groupName)
+--------------------
+
+Given a key, or an array of keys, places options under an alternative heading
+when displaying usage instructions, e.g.,
+
+```js
+var yargs = require('yargs')(['--help'])
+  .help('help')
+  .group('batman', 'Heroes:')
+  .describe('batman', "world's greatest detective")
+  .wrap(null)
+  .argv
+```
+***
+    Heroes:
+      --batman  world's greatest detective
+
+    Options:
+      --help  Show help  [boolean]
+
 .help([option, [description]])
 ------------------------------
 
@@ -719,16 +830,23 @@ Locales currently supported:
 * **en:** American English.
 * **es:** Spanish.
 * **fr:** French.
+* **id:** Indonesian.
 * **ja:** Japanese.
+* **ko:** Korean.
+* **nb:** Norwegian Bokmål.
+* **pirate:** American Pirate.
 * **pt:** Portuguese.
+* **pt_BR:** Brazilian Portuguese.
+* **tr:** Turkish.
 * **zh:** Chinese.
-* **pirate:** American Pirate.
 
 To submit a new translation for yargs:
 
 1. use `./locales/en.json` as a starting point.
 2. submit a pull request with the new locale file.
 
+*The [Microsoft Terminology Search](http://www.microsoft.com/Language/en-US/Search.aspx) can be useful for finding the correct terminology in your locale.*
+
 <a name="nargs"></a>.nargs(key, count)
 -----------
 
@@ -807,11 +925,13 @@ Valid `opt` keys include:
 - `boolean`: boolean, interpret option as a boolean flag, see [`boolean()`](#boolean)
 - `choices`: value or array of values, limit valid option arguments to a predefined set, see [`choices()`](#choices)
 - `config`: boolean, interpret option as a path to a JSON config file, see [`config()`](#config)
+- `configParser`: function, provide a custom config parsing function, see [`config()`](#config)
 - `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)
 - `desc`/`describe`/`description`: string, the option description for help content, see [`describe()`](#describe)
+- `group`: string, when displaying usage instructions place the option under an alternative group heading, see [`group()`](#group)
 - `nargs`: number, specify how many arguments should be consumed for the option, see [`nargs()`](#nargs)
 - `requiresArg`: boolean, require the option be specified with a value, see [`requiresArg()`](#requiresArg)
 - `string`: boolean, interpret option as a string, see [`string()`](#string)
@@ -826,6 +946,8 @@ Valid `opt` keys include:
 
 Parse `args` instead of `process.argv`. Returns the `argv` object.
 
+`args` may either be a pre-processed argv array, or a raw argument string.
+
 .require(key, [msg | boolean])
 ------------------------------
 .required(key, [msg | boolean])
@@ -1089,7 +1211,7 @@ Short numeric `-n5` style arguments work too:
 installation
 ============
 
-With [npm](http://github.com/isaacs/npm), just do:
+With [npm](https://github.com/npm/npm), just do:
 
     npm install yargs
 
@@ -1115,7 +1237,7 @@ This module is loosely inspired by Perl's
 [gemnasium-image]: https://img.shields.io/gemnasium/bcoe/yargs.svg
 [coveralls-url]: https://coveralls.io/github/bcoe/yargs
 [coveralls-image]: https://img.shields.io/coveralls/bcoe/yargs.svg
-[npm-url]: https://npmjs.org/package/yargs
+[npm-url]: https://www.npmjs.com/package/yargs
 [npm-image]: https://img.shields.io/npm/v/yargs.svg
 [windows-url]: https://ci.appveyor.com/project/bcoe/yargs
 [windows-image]: https://img.shields.io/appveyor/ci/bcoe/yargs/master.svg?label=Windows%20Tests

package/index.js

@@ -2,6 +2,7 @@ var assert = require('assert')
 var Completion = require('./lib/completion')
 var Parser = require('./lib/parser')
 var path = require('path')
+var tokenizeArgString = require('./lib/tokenize-arg-string')
 var Usage = require('./lib/usage')
 var Validation = require('./lib/validation')
 var Y18n = require('y18n')
@@ -58,7 +59,8 @@ function Argv (processArgs, cwd) {
       requiresArg: [],
       count: [],
       normalize: [],
-      config: []
+      config: {},
+      envPrefix: undefined
     }
 
     usage = Usage(self, y18n) // handle usage output.
@@ -66,6 +68,7 @@ function Argv (processArgs, cwd) {
     completion = Completion(self, usage)
 
     demanded = {}
+    groups = {}
 
     exitProcess = true
     strict = false
@@ -115,9 +118,15 @@ function Argv (processArgs, cwd) {
     return self
   }
 
-  self.config = function (key, msg) {
+  self.config = function (key, msg, parseFn) {
+    if (typeof msg === 'function') {
+      parseFn = msg
+      msg = null
+    }
     self.describe(key, msg || usage.deferY18nLookup('Path to JSON config file'))
-    options.config.push.apply(options.config, [].concat(key))
+    ;(Array.isArray(key) ? key : [key]).forEach(function (k) {
+      options.config[k] = parseFn || true
+    })
     return self
   }
 
@@ -166,7 +175,25 @@ function Argv (processArgs, cwd) {
         self.alias(key, x[key])
       })
     } else {
-      options.alias[x] = (options.alias[x] || []).concat(y)
+      // perhaps 'x' is already an alias in another list?
+      // if so we should append to x's list.
+      var aliases = null
+      Object.keys(options.alias).forEach(function (key) {
+        if (~options.alias[key].indexOf(x)) aliases = options.alias[key]
+      })
+
+      if (aliases) { // x was an alias itself.
+        aliases.push(y)
+      } else { // x is a new alias key.
+        options.alias[x] = (options.alias[x] || []).concat(y)
+      }
+
+      // wait! perhaps we've created two lists of aliases
+      // that reference each other?
+      if (options.alias[y]) {
+        Array.prototype.push.apply((options.alias[x] || aliases), options.alias[y])
+        delete options.alias[y]
+      }
     }
     return self
   }
@@ -275,13 +302,15 @@ function Argv (processArgs, cwd) {
       if (demand) {
         self.demand(key, demand)
       } if ('config' in opt) {
-        self.config(key)
+        self.config(key, opt.configParser)
       } if ('default' in opt) {
         self.default(key, opt.default)
       } if ('nargs' in opt) {
         self.nargs(key, opt.nargs)
       } if ('choices' in opt) {
         self.choices(key, opt.choices)
+      } if ('group' in opt) {
+        self.group(key, opt.group)
       } if (opt.boolean || opt.type === 'boolean') {
         self.boolean(key)
         if (opt.alias) self.boolean(opt.alias)
@@ -313,6 +342,27 @@ function Argv (processArgs, cwd) {
     return options
   }
 
+  var groups = {}
+  self.group = function (opts, groupName) {
+    var seen = {}
+    groups[groupName] = (groups[groupName] || []).concat(opts).filter(function (key) {
+      if (seen[key]) return false
+      return (seen[key] = true)
+    })
+    return self
+  }
+  self.getGroups = function () {
+    return groups
+  }
+
+  // as long as options.envPrefix is not undefined,
+  // parser will apply env vars matching prefix to argv
+  self.env = function (prefix) {
+    if (prefix === false) options.envPrefix = undefined
+    else options.envPrefix = prefix || ''
+    return self
+  }
+
   self.wrap = function (cols) {
     usage.wrap(cols)
     return self
@@ -457,6 +507,8 @@ function Argv (processArgs, cwd) {
   })
 
   function parseArgs (args) {
+    args = normalizeArgs(args)
+
     var parsed = Parser(args, options, y18n)
     var argv = parsed.argv
     var aliases = parsed.aliases
@@ -481,7 +533,7 @@ function Argv (processArgs, cwd) {
     var handlerKeys = Object.keys(self.getCommandHandlers())
     for (var i = 0, command; (command = handlerKeys[i]) !== undefined; i++) {
       if (~argv._.indexOf(command)) {
-        self.getCommandHandlers()[command](self.reset())
+        runCommand(command, self, argv)
         return self.argv
       }
     }
@@ -563,13 +615,28 @@ function Argv (processArgs, cwd) {
     }
   }
 
+  function runCommand (command, yargs, argv) {
+    setPlaceholderKeys(argv)
+    yargs.getCommandHandlers()[command](yargs.reset(), argv)
+  }
+
   function setPlaceholderKeys (argv) {
     Object.keys(options.key).forEach(function (key) {
+      // don't set placeholder keys for dot
+      // notation options 'foo.bar'.
+      if (~key.indexOf('.')) return
       if (typeof argv[key] === 'undefined') argv[key] = undefined
     })
   }
 
-  sigletonify(self)
+  function normalizeArgs (args) {
+    if (typeof args === 'string') {
+      return tokenizeArgString(args)
+    }
+    return args
+  }
+
+  singletonify(self)
   return self
 }
 
@@ -587,7 +654,7 @@ function rebase (base, dir) {
     require('yargs').argv
     to get a parsed version of process.argv.
 */
-function sigletonify (inst) {
+function singletonify (inst) {
   Object.keys(inst).forEach(function (key) {
     if (key === 'argv') {
       Argv.__defineGetter__(key, inst.__lookupGetter__(key))

package/lib/completion.js

@@ -19,8 +19,19 @@ module.exports = function (yargs, usage) {
     // to completion().
     if (completionFunction) {
       if (completionFunction.length < 3) {
+        var result = completionFunction(current, argv)
+
+        // promise based completion function.
+        if (typeof result.then === 'function') {
+          return result.then(function (list) {
+            process.nextTick(function () { done(list) })
+          }).catch(function (err) {
+            process.nextTick(function () { throw err })
+          })
+        }
+
         // synchronous completion function.
-        return done(completionFunction(current, argv))
+        return done(result)
       } else {
         // asynchronous completion function
         return completionFunction(current, argv, function (completions) {

package/lib/parser.js

@@ -34,8 +34,8 @@ module.exports = function (args, opts, y18n) {
     flags.normalize[key] = true
   })
 
-  ;[].concat(opts.config).filter(Boolean).forEach(function (key) {
-    flags.configs[key] = true
+  Object.keys(opts.config).forEach(function (k) {
+    flags.configs[k] = opts.config[k]
   })
 
   var aliases = {}
@@ -43,6 +43,7 @@ module.exports = function (args, opts, y18n) {
 
   extendAliases(opts.key)
   extendAliases(opts.alias)
+  extendAliases(opts.default)
 
   var defaults = opts['default'] || {}
   Object.keys(defaults).forEach(function (key) {
@@ -220,7 +221,14 @@ module.exports = function (args, opts, y18n) {
     }
   }
 
+  // order of precedence:
+  // 1. command line arg
+  // 2. value from config file
+  // 3. value from env var
+  // 4. configured default value
+  applyEnvVars(opts, argv, true) // special case: check env vars that point to config file
   setConfig(argv)
+  applyEnvVars(opts, argv, false)
   applyDefaultsAndAliases(argv, aliases, defaults)
 
   Object.keys(flags.counts).forEach(function (key) {
@@ -281,6 +289,15 @@ module.exports = function (args, opts, y18n) {
     var splitKey = key.split('.')
     setKey(argv, splitKey, value)
 
+    // alias references an inner-value within
+    // a dot-notation object. see #279.
+    if (~key.indexOf('.') && aliases[key]) {
+      aliases[key].forEach(function (x) {
+        x = x.split('.')
+        setKey(argv, x, value)
+      })
+    }
+
     ;(aliases[splitKey[0]] || []).forEach(function (x) {
       x = x.split('.')
 
@@ -325,7 +342,22 @@ module.exports = function (args, opts, y18n) {
       var configPath = argv[configKey] || configLookup[configKey]
       if (configPath) {
         try {
-          var config = require(path.resolve(process.cwd(), configPath))
+          var config = null
+          var resolvedConfigPath = path.resolve(process.cwd(), configPath)
+
+          if (typeof flags.configs[configKey] === 'function') {
+            try {
+              config = flags.configs[configKey](resolvedConfigPath)
+            } catch (e) {
+              config = e
+            }
+            if (config instanceof Error) {
+              error = config
+              return
+            }
+          } else {
+            config = require(resolvedConfigPath)
+          }
 
           Object.keys(config).forEach(function (key) {
             // setting arguments via CLI takes precedence over
@@ -342,12 +374,27 @@ module.exports = function (args, opts, y18n) {
     })
   }
 
+  function applyEnvVars (opts, argv, configOnly) {
+    if (typeof opts.envPrefix === 'undefined') return
+
+    var prefix = typeof opts.envPrefix === 'string' ? opts.envPrefix : ''
+    Object.keys(process.env).forEach(function (envVar) {
+      if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) {
+        var key = camelCase(envVar.substring(prefix.length))
+        if (((configOnly && flags.configs[key]) || !configOnly) && (!(key in argv) || flags.defaulted[key])) {
+          setArg(key, process.env[envVar])
+        }
+      }
+    })
+  }
+
   function applyDefaultsAndAliases (obj, aliases, defaults) {
     Object.keys(defaults).forEach(function (key) {
       if (!hasKey(obj, key.split('.'))) {
         setKey(obj, key.split('.'), defaults[key])
 
         ;(aliases[key] || []).forEach(function (x) {
+          if (hasKey(obj, x.split('.'))) return
           setKey(obj, x.split('.'), defaults[key])
         })
       }
@@ -361,7 +408,9 @@ module.exports = function (args, opts, y18n) {
     })
 
     var key = keys[keys.length - 1]
-    return key in o
+
+    if (typeof o !== 'object') return false
+    else return key in o
   }
 
   function setKey (obj, keys, value) {
@@ -388,6 +437,11 @@ module.exports = function (args, opts, y18n) {
   // extend the aliases list with inferred aliases.
   function extendAliases (obj) {
     Object.keys(obj || {}).forEach(function (key) {
+      // short-circuit if we've already added a key
+      // to the aliases array, for example it might
+      // exist in both 'opts.default' and 'opts.key'.
+      if (aliases[key]) return
+
       aliases[key] = [].concat(opts.alias[key] || [])
       // For "--option-name", also set argv.optionName
       aliases[key].concat(key).forEach(function (x) {

package/lib/tokenize-arg-string.js

@@ -0,0 +1,32 @@
+// take an un-split argv string and tokenize it.
+module.exports = function (argString) {
+  var i = 0
+  var c = null
+  var opening = null
+  var args = []
+
+  for (var ii = 0; ii < argString.length; ii++) {
+    c = argString.charAt(ii)
+
+    // split on spaces unless we're in quotes.
+    if (c === ' ' && !opening) {
+      i++
+      continue
+    }
+
+    // don't split the string if we're in matching
+    // opening or closing single and double quotes.
+    if (c === opening) {
+      opening = null
+      continue
+    } else if ((c === "'" || c === '"') && !opening) {
+      opening = c
+      continue
+    }
+
+    if (!args[i]) args[i] = ''
+    args[i] += c
+  }
+
+  return args
+}

package/lib/usage.js

@@ -2,6 +2,7 @@
 // failures, etc. keeps logging in one place.
 var cliui = require('cliui')
 var decamelize = require('decamelize')
+var stringWidth = require('string-width')
 var wsize = require('window-size')
 
 module.exports = function (yargs, y18n) {
@@ -101,10 +102,12 @@ module.exports = function (yargs, y18n) {
     return deferY18nLookupPrefix + str
   }
 
+  var defaultGroup = 'Options:'
   self.help = function () {
     normalizeAliases()
 
     var demanded = yargs.getDemanded()
+    var groups = yargs.getGroups()
     var options = yargs.getOptions()
     var keys = Object.keys(
       Object.keys(descriptions)
@@ -141,7 +144,8 @@ module.exports = function (yargs, y18n) {
       ui.div()
     }
 
-    // the options table.
+    // perform some cleanup on the keys array, making it
+    // only include top-level keys not their aliases.
     var aliasKeys = (Object.keys(options.alias) || [])
       .concat(Object.keys(yargs.parsed.newAliases) || [])
 
@@ -151,20 +155,39 @@ module.exports = function (yargs, y18n) {
       })
     })
 
-    var switches = keys.reduce(function (acc, key) {
-      acc[key] = [ key ].concat(options.alias[key] || [])
-      .map(function (sw) {
-        return (sw.length > 1 ? '--' : '-') + sw
+    // populate 'Options:' group with any keys that have not
+    // explicitly had a group set.
+    if (!groups[defaultGroup]) groups[defaultGroup] = []
+    addUngroupedKeys(keys, options.alias, groups)
+
+    // display 'Options:' table along with any custom tables:
+    Object.keys(groups).forEach(function (groupName) {
+      if (!groups[groupName].length) return
+
+      ui.div(__(groupName))
+
+      // if we've grouped the key 'f', but 'f' aliases 'foobar',
+      // normalizedKeys should contain only 'foobar'.
+      var normalizedKeys = groups[groupName].map(function (key) {
+        if (~aliasKeys.indexOf(key)) return key
+        for (var i = 0, aliasKey; (aliasKey = aliasKeys[i]) !== undefined; i++) {
+          if (~(options.alias[aliasKey] || []).indexOf(key)) return aliasKey
+        }
+        return key
       })
-      .join(', ')
 
-      return acc
-    }, {})
+      // actually generate the switches string --foo, -f, --bar.
+      var switches = normalizedKeys.reduce(function (acc, key) {
+        acc[key] = [ key ].concat(options.alias[key] || [])
+          .map(function (sw) {
+            return (sw.length > 1 ? '--' : '-') + sw
+          })
+          .join(', ')
 
-    if (keys.length) {
-      ui.div(__('Options:'))
+        return acc
+      }, {})
 
-      keys.forEach(function (key) {
+      normalizedKeys.forEach(function (key) {
         var kswitch = switches[key]
         var desc = descriptions[key] || ''
         var type = null
@@ -195,7 +218,7 @@ module.exports = function (yargs, y18n) {
       })
 
       ui.div()
-    }
+    })
 
     // describe some common use-cases for your application.
     if (examples.length) {
@@ -238,7 +261,7 @@ module.exports = function (yargs, y18n) {
     }
 
     table.forEach(function (v) {
-      width = Math.max(v[0].length, width)
+      width = Math.max(stringWidth(v[0]), width)
     })
 
     // if we've enabled 'wrap' we should limit
@@ -260,7 +283,6 @@ module.exports = function (yargs, y18n) {
         if (descriptions[alias]) self.describe(key, descriptions[alias])
         // copy demanded.
         if (demanded[alias]) yargs.demand(key, demanded[alias].msg)
-
         // type messages.
         if (~options.boolean.indexOf(alias)) yargs.boolean(key)
         if (~options.count.indexOf(alias)) yargs.count(key)
@@ -271,6 +293,26 @@ module.exports = function (yargs, y18n) {
     })
   }
 
+  // given a set of keys, place any keys that are
+  // ungrouped under the 'Options:' grouping.
+  function addUngroupedKeys (keys, aliases, groups) {
+    var groupedKeys = []
+    var toCheck = null
+    Object.keys(groups).forEach(function (group) {
+      groupedKeys = groupedKeys.concat(groups[group])
+    })
+
+    keys.forEach(function (key) {
+      toCheck = [key].concat(aliases[key])
+      if (!toCheck.some(function (k) {
+        return groupedKeys.indexOf(k) !== -1
+      })) {
+        groups[defaultGroup].push(key)
+      }
+    })
+    return groupedKeys
+  }
+
   self.showHelp = function (level) {
     level = level || 'error'
     console[level](self.help())

package/locales/id.json

@@ -0,0 +1,37 @@
+
+{
+  "Commands:": "Perintah:",
+  "Options:": "Pilihan:",
+  "Examples:": "Contoh:",
+  "boolean": "boolean",
+  "count": "jumlah",
+  "string": "string",
+  "array": "larik",
+  "required": "diperlukan",
+  "default:": "bawaan:",
+  "choices:": "pilihan:",
+  "generated-value": "nilai-yang-dihasilkan",
+  "Not enough non-option arguments: got %s, need at least %s": "Argumen wajib kurang: hanya %s, minimal %s",
+  "Too many non-option arguments: got %s, maximum of %s": "Terlalu banyak argumen wajib: ada %s, maksimal %s",
+  "Missing argument value: %s": {
+    "one": "Kurang argumen: %s",
+    "other": "Kurang argumen: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Kurang argumen wajib: %s",
+    "other": "Kurang argumen wajib: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Argumen tak diketahui: %s",
+    "other": "Argumen tak diketahui: %s"
+  },
+  "Invalid values:": "Nilai-nilai tidak valid:",
+  "Argument: %s, Given: %s, Choices: %s": "Argumen: %s, Diberikan: %s, Pilihan: %s",
+  "Argument check failed: %s": "Pemeriksaan argument gagal: %s",
+  "Implications failed:": "Implikasi gagal:",
+  "Not enough arguments following: %s": "Kurang argumen untuk: %s",
+  "Invalid JSON config file: %s": "Berkas konfigurasi JSON tidak valid: %s",
+  "Path to JSON config file": "Alamat berkas konfigurasi JSON",
+  "Show help": "Lihat bantuan",
+  "Show version number": "Lihat nomor versi"
+}

package/locales/ko.json

@@ -0,0 +1,36 @@
+{
+  "Commands:": "명령:",
+  "Options:": "옵션:",
+  "Examples:": "예시:",
+  "boolean": "여부",
+  "count": "개수",
+  "string": "문자열",
+  "array": "배열",
+  "required": "필수",
+  "default:": "기본:",
+  "choices:": "선택:",
+  "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": "버전 넘버를 보여줍니다"
+}

package/locales/nb.json

@@ -0,0 +1,36 @@
+{
+  "Commands:": "Kommandoer:",
+  "Options:": "Alternativer:",
+  "Examples:": "Eksempler:",
+  "boolean": "boolsk",
+  "count": "antall",
+  "string": "streng",
+  "array": "matrise",
+  "required": "obligatorisk",
+  "default:": "standard:",
+  "choices:": "valg:",
+  "generated-value": "generert-verdi",
+  "Not enough non-option arguments: got %s, need at least %s": "Ikke nok ikke-alternativ argumenter: fikk %s, trenger minst %s",
+  "Too many non-option arguments: got %s, maximum of %s": "For mange ikke-alternativ argumenter: fikk %s, maksimum %s",
+  "Missing argument value: %s": {
+    "one": "Mangler argument verdi: %s",
+    "other": "Mangler argument verdier: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Mangler obligatorisk argument: %s",
+    "other": "Mangler obligatoriske argumenter: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Ukjent argument: %s",
+    "other": "Ukjente argumenter: %s"
+  },
+  "Invalid values:": "Ugyldige verdier:",
+  "Argument: %s, Given: %s, Choices: %s": "Argument: %s, Gitt: %s, Valg: %s",
+  "Argument check failed: %s": "Argument sjekk mislyktes: %s",
+  "Implications failed:": "Konsekvensene mislyktes:",
+  "Not enough arguments following: %s": "Ikke nok følgende argumenter: %s",
+  "Invalid JSON config file: %s": "Ugyldig JSON konfigurasjonsfil: %s",
+  "Path to JSON config file": "Bane til JSON konfigurasjonsfil",
+  "Show help": "Vis hjelp",
+  "Show version number": "Vis versjonsnummer"
+}

package/locales/pl.json

@@ -0,0 +1,36 @@
+{
+  "Commands:": "Polecenia:",
+  "Options:": "Opcje:",
+  "Examples:": "Przykłady:",
+  "boolean": "boolean",
+  "count": "ilość",
+  "string": "ciąg znaków",
+  "array": "tablica",
+  "required": "wymagany",
+  "default:": "domyślny:",
+  "choices:": "dostępne:",
+  "generated-value": "wygenerowana-wartość",
+  "Not enough non-option arguments: got %s, need at least %s": "Niewystarczająca ilość argumentów: otrzymano %s, wymagane co najmniej %s",
+  "Too many non-option arguments: got %s, maximum of %s": "Zbyt duża ilość argumentów: otrzymano %s, wymagane co najwyżej %s",
+  "Missing argument value: %s": {
+    "one": "Brak wartości dla argumentu: %s",
+    "other": "Brak wartości dla argumentów: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Brak wymaganego argumentu: %s",
+    "other": "Brak wymaganych argumentów: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Nieznany argument: %s",
+    "other": "Nieznane argumenty: %s"
+  },
+  "Invalid values:": "Nieprawidłowe wartości:",
+  "Argument: %s, Given: %s, Choices: %s": "Argument: %s, Otrzymano: %s, Dostępne: %s",
+  "Argument check failed: %s": "Weryfikacja argumentów nie powiodła się: %s",
+  "Implications failed:": "Założenia nie zostały spełnione:",
+  "Not enough arguments following: %s": "Niewystarczająca ilość argumentów następujących po: %s",
+  "Invalid JSON config file: %s": "Nieprawidłowy plik konfiguracyjny JSON: %s",
+  "Path to JSON config file": "Ścieżka do pliku konfiguracyjnego JSON",
+  "Show help": "Pokaż pomoc",
+  "Show version number": "Pokaż numer wersji"
+}

package/locales/pt_BR.json

@@ -0,0 +1,36 @@
+{
+  "Commands:": "Comandos:",
+  "Options:": "Opções:",
+  "Examples:": "Exemplos:",
+  "boolean": "boolean",
+  "count": "contagem",
+  "string": "string",
+  "array": "array",
+  "required": "obrigatório",
+  "default:": "padrão:",
+  "choices:": "opções:",
+  "generated-value": "valor-gerado",
+  "Not enough non-option arguments: got %s, need at least %s": "Argumentos insuficientes: Argumento %s, necessário pelo menos %s",
+  "Too many non-option arguments: got %s, maximum of %s": "Excesso de argumentos: recebido %s, máximo de %s",
+  "Missing argument value: %s": {
+    "one": "Falta valor de argumento: %s",
+    "other": "Falta valores de argumento: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Falta argumento obrigatório: %s",
+    "other": "Faltando argumentos obrigatórios: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Argumento desconhecido: %s",
+    "other": "Argumentos desconhecidos: %s"
+  },
+  "Invalid values:": "Valores inválidos:",
+  "Argument: %s, Given: %s, Choices: %s": "Argumento: %s, Dado: %s, Opções: %s",
+  "Argument check failed: %s": "Verificação de argumento falhou: %s",
+  "Implications failed:": "Implicações falharam:",
+  "Not enough arguments following: %s": "Argumentos insuficientes a seguir: %s",
+  "Invalid JSON config file: %s": "Arquivo JSON de configuração inválido: %s",
+  "Path to JSON config file": "Caminho para o arquivo JSON de configuração",
+  "Show help": "Exibe ajuda",
+  "Show version number": "Exibe a versão"
+}

package/locales/tr.json

@@ -0,0 +1,36 @@
+{
+  "Commands:": "Komutlar:",
+  "Options:": "Seçenekler:",
+  "Examples:": "Örnekler:",
+  "boolean": "boolean",
+  "count": "sayı",
+  "string": "string",
+  "array": "array",
+  "required": "zorunlu",
+  "default:": "varsayılan:",
+  "choices:": "seçimler:",
+  "generated-value": "oluşturulan-değer",
+  "Not enough non-option arguments: got %s, need at least %s": "Seçenek dışı argümanlar yetersiz: %s bulundu, %s gerekli",
+  "Too many non-option arguments: got %s, maximum of %s": "Seçenek dışı argümanlar gereğinden fazla: %s bulundu, azami %s",
+  "Missing argument value: %s": {
+    "one": "Eksik argüman değeri: %s",
+    "other": "Eksik argüman değerleri: %s"
+  },
+  "Missing required argument: %s": {
+    "one": "Eksik zorunlu argüman: %s",
+    "other": "Eksik zorunlu argümanlar: %s"
+  },
+  "Unknown argument: %s": {
+    "one": "Bilinmeyen argüman: %s",
+    "other": "Bilinmeyen argümanlar: %s"
+  },
+  "Invalid values:": "Geçersiz değerler:",
+  "Argument: %s, Given: %s, Choices: %s": "Argüman: %s, Verilen: %s, Seçimler: %s",
+  "Argument check failed: %s": "Argüman kontrolü başarısız oldu: %s",
+  "Implications failed:": "Sonuçlar başarısız oldu:",
+  "Not enough arguments following: %s": "%s için yeterli argüman bulunamadı",
+  "Invalid JSON config file: %s": "Geçersiz JSON yapılandırma dosyası: %s",
+  "Path to JSON config file": "JSON yapılandırma dosya konumu",
+  "Show help": "Yardım detaylarını göster",
+  "Show version number": "Versiyon detaylarını göster"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yargs",
-  "version": "3.28.0",
+  "version": "3.32.0",
   "description": "Light-weight option parsing with an argv hash. No optstrings attached.",
   "main": "./index.js",
   "files": [
@@ -11,26 +11,29 @@
     "LICENSE"
   ],
   "dependencies": {
-    "camelcase": "^1.2.1",
-    "cliui": "^3.0.2",
-    "decamelize": "^1.0.0",
+    "camelcase": "^2.0.1",
+    "cliui": "^3.0.3",
+    "decamelize": "^1.1.1",
     "os-locale": "^1.4.0",
-    "window-size": "^0.1.2",
+    "string-width": "^1.0.1",
+    "window-size": "^0.1.4",
     "y18n": "^3.2.0"
   },
   "devDependencies": {
-    "chai": "^3.3.0",
+    "chai": "^3.4.1",
     "chalk": "^1.1.1",
     "coveralls": "^2.11.4",
+    "es6-promise": "^3.0.2",
     "hashish": "0.0.4",
-    "mocha": "^2.3.3",
-    "nyc": "^3.2.2",
-    "standard": "^5.3.1",
+    "mocha": "^2.3.4",
+    "nyc": "^5.2.0",
+    "standard": "^5.4.1",
     "which": "^1.1.2",
     "win-spawn": "^2.0.0"
   },
   "scripts": {
-    "test": "standard && nyc ./node_modules/.bin/_mocha --timeout=4000 --check-leaks",
+    "pretest": "standard",
+    "test": "nyc --cache mocha --timeout=4000 --check-leaks",
     "coverage": "nyc report --reporter=text-lcov | coveralls"
   },
   "repository": {
@@ -94,6 +97,6 @@
   ],
   "license": "MIT",
   "engine": {
-    "node": ">=0.4"
+    "node": ">=0.10"
   }
 }