1. module nopt
   1. function nopt (types, shorthands, args, slice)
   2. function nopt.clean (data, types, typeDefs)
   3. object nopt.typeDefs

module nopt

function nopt (types, shorthands, args, slice)

• description and source-code

  function nopt(types, shorthands, args, slice) {
    args = args || process.argv
    types = types || {}
    shorthands = shorthands || {}
    if (typeof slice !== "number") slice = 2
  
    debug(types, shorthands, args, slice)
  
    args = args.slice(slice)
    var data = {}
      , key
      , argv = {
          remain: [],
          cooked: args,
          original: args.slice(0)
        }
  
    parse(args, data, argv.remain, types, shorthands)
    // now data is full
    clean(data, types, exports.typeDefs)
    data.argv = argv
    Object.defineProperty(data.argv, 'toString', { value: function () {
      return this.original.map(JSON.stringify).join(" ")
    }, enumerable: false })
    return data
  }

• example usage

  n/a

function nopt.clean (data, types, typeDefs)

• description and source-code

  function clean(data, types, typeDefs) {
    typeDefs = typeDefs || exports.typeDefs
    var remove = {}
      , typeDefault = [false, true, null, String, Array]
  
    Object.keys(data).forEach(function (k) {
      if (k === "argv") return
      var val = data[k]
        , isArray = Array.isArray(val)
        , type = types[k]
      if (!isArray) val = [val]
      if (!type) type = typeDefault
      if (type === Array) type = typeDefault.concat(Array)
      if (!Array.isArray(type)) type = [type]
  
      debug("val=%j", val)
      debug("types=", type)
      val = val.map(function (val) {
        // if it's an unknown value, then parse false/true/null/numbers/dates
        if (typeof val === "string") {
          debug("string %j", val)
          val = val.trim()
          if ((val === "null" && ~type.indexOf(null))
              || (val === "true" &&
                 (~type.indexOf(true) || ~type.indexOf(Boolean)))
              || (val === "false" &&
                 (~type.indexOf(false) || ~type.indexOf(Boolean)))) {
            val = JSON.parse(val)
            debug("jsonable %j", val)
          } else if (~type.indexOf(Number) && !isNaN(val)) {
            debug("convert to number", val)
            val = +val
          } else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
            debug("convert to date", val)
            val = new Date(val)
          }
        }
  
        if (!types.hasOwnProperty(k)) {
          return val
        }
  
        // allow `--no-blah` to set 'blah' to null if null is allowed
        if (val === false && ~type.indexOf(null) &&
            !(~type.indexOf(false) || ~type.indexOf(Boolean))) {
          val = null
        }
  
        var d = {}
        d[k] = val
        debug("prevalidated val", d, val, types[k])
        if (!validate(d, k, val, types[k], typeDefs)) {
          if (exports.invalidHandler) {
            exports.invalidHandler(k, val, types[k], data)
          } else if (exports.invalidHandler !== false) {
            debug("invalid: "+k+"="+val, types[k])
          }
          return remove
        }
        debug("validated val", d, val, types[k])
        return d[k]
      }).filter(function (val) { return val !== remove })
  
      if (!val.length) delete data[k]
      else if (isArray) {
        debug(isArray, data[k], val)
        data[k] = val
      } else data[k] = val[0]
  
      debug("k=%s val=%j", k, val, data[k])
    })
  }

• example usage

  ...
  hash is an object with a `type` member and a `validate` method.  The
  `type` member is an object that matches what goes in the type list.  The
  `validate` method is a function that gets called with `validate(data,
  key, val)`.  Validate methods should assign `data[key]` to the valid
  value of `val` if it can be handled properly, or return boolean
  `false` if it cannot.
  
  You can also call `nopt.clean(data, types, typeDefs)` to clean up a
  config object and remove its invalid properties.
  
  ## Error Handling
  
  By default, nopt outputs a warning to standard error when invalid values for
  known options are found.  You can change this behavior by assigning a method
  to `nopt.invalidHandler`.  This method will be called with
  ...