yargs 3.31.0 → 3.32.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## 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)

package/README.md

@@ -549,15 +549,28 @@ var argv = require('yargs')
   .argv;
 ```
 
-<a name="config"></a>.config(key, [description])
+<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)
 ------------
 
@@ -912,6 +925,7 @@ 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)
@@ -932,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])

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,7 @@ function Argv (processArgs, cwd) {
       requiresArg: [],
       count: [],
       normalize: [],
-      config: [],
+      config: {},
       envPrefix: undefined
     }
 
@@ -67,6 +68,7 @@ function Argv (processArgs, cwd) {
     completion = Completion(self, usage)
 
     demanded = {}
+    groups = {}
 
     exitProcess = true
     strict = false
@@ -116,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
   }
 
@@ -294,7 +302,7 @@ 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) {
@@ -336,7 +344,11 @@ function Argv (processArgs, cwd) {
 
   var groups = {}
   self.group = function (opts, groupName) {
-    groups[groupName] = (groups[groupName] || []).concat(opts)
+    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 () {
@@ -495,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
@@ -615,7 +629,14 @@ function Argv (processArgs, cwd) {
     })
   }
 
-  sigletonify(self)
+  function normalizeArgs (args) {
+    if (typeof args === 'string') {
+      return tokenizeArgString(args)
+    }
+    return args
+  }
+
+  singletonify(self)
   return self
 }
 
@@ -633,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/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) {
@@ -341,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
@@ -421,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yargs",
-  "version": "3.31.0",
+  "version": "3.32.0",
   "description": "Light-weight option parsing with an argv hash. No optstrings attached.",
   "main": "./index.js",
   "files": [
@@ -26,13 +26,14 @@
     "es6-promise": "^3.0.2",
     "hashish": "0.0.4",
     "mocha": "^2.3.4",
-    "nyc": "^4.0.1",
+    "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": {
@@ -96,6 +97,6 @@
   ],
   "license": "MIT",
   "engine": {
-    "node": ">=0.4"
+    "node": ">=0.10"
   }
 }