www.aleph1.co.uk Git - yaffs-website/blob - node_modules/nopt/lib/nopt.js

   1 // info about each config option.
   2
   3 var debug = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG
   4   ? function () { console.error.apply(console, arguments) }
   5   : function () {}
   6
   7 var url = require("url")
   8   , path = require("path")
   9   , Stream = require("stream").Stream
  10   , abbrev = require("abbrev")
  11
  12 module.exports = exports = nopt
  13 exports.clean = clean
  14
  15 exports.typeDefs =
  16   { String  : { type: String,  validate: validateString  }
  17   , Boolean : { type: Boolean, validate: validateBoolean }
  18   , url     : { type: url,     validate: validateUrl     }
  19   , Number  : { type: Number,  validate: validateNumber  }
  20   , path    : { type: path,    validate: validatePath    }
  21   , Stream  : { type: Stream,  validate: validateStream  }
  22   , Date    : { type: Date,    validate: validateDate    }
  23   }
  24
  25 function nopt (types, shorthands, args, slice) {
  26   args = args || process.argv
  27   types = types || {}
  28   shorthands = shorthands || {}
  29   if (typeof slice !== "number") slice = 2
  30
  31   debug(types, shorthands, args, slice)
  32
  33   args = args.slice(slice)
  34   var data = {}
  35     , key
  36     , remain = []
  37     , cooked = args
  38     , original = args.slice(0)
  39
  40   parse(args, data, remain, types, shorthands)
  41   // now data is full
  42   clean(data, types, exports.typeDefs)
  43   data.argv = {remain:remain,cooked:cooked,original:original}
  44   Object.defineProperty(data.argv, 'toString', { value: function () {
  45     return this.original.map(JSON.stringify).join(" ")
  46   }, enumerable: false })
  47   return data
  48 }
  49
  50 function clean (data, types, typeDefs) {
  51   typeDefs = typeDefs || exports.typeDefs
  52   var remove = {}
  53     , typeDefault = [false, true, null, String, Array]
  54
  55   Object.keys(data).forEach(function (k) {
  56     if (k === "argv") return
  57     var val = data[k]
  58       , isArray = Array.isArray(val)
  59       , type = types[k]
  60     if (!isArray) val = [val]
  61     if (!type) type = typeDefault
  62     if (type === Array) type = typeDefault.concat(Array)
  63     if (!Array.isArray(type)) type = [type]
  64
  65     debug("val=%j", val)
  66     debug("types=", type)
  67     val = val.map(function (val) {
  68       // if it's an unknown value, then parse false/true/null/numbers/dates
  69       if (typeof val === "string") {
  70         debug("string %j", val)
  71         val = val.trim()
  72         if ((val === "null" && ~type.indexOf(null))
  73             || (val === "true" &&
  74                (~type.indexOf(true) || ~type.indexOf(Boolean)))
  75             || (val === "false" &&
  76                (~type.indexOf(false) || ~type.indexOf(Boolean)))) {
  77           val = JSON.parse(val)
  78           debug("jsonable %j", val)
  79         } else if (~type.indexOf(Number) && !isNaN(val)) {
  80           debug("convert to number", val)
  81           val = +val
  82         } else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
  83           debug("convert to date", val)
  84           val = new Date(val)
  85         }
  86       }
  87
  88       if (!types.hasOwnProperty(k)) {
  89         return val
  90       }
  91
  92       // allow `--no-blah` to set 'blah' to null if null is allowed
  93       if (val === false && ~type.indexOf(null) &&
  94           !(~type.indexOf(false) || ~type.indexOf(Boolean))) {
  95         val = null
  96       }
  97
  98       var d = {}
  99       d[k] = val
 100       debug("prevalidated val", d, val, types[k])
 101       if (!validate(d, k, val, types[k], typeDefs)) {
 102         if (exports.invalidHandler) {
 103           exports.invalidHandler(k, val, types[k], data)
 104         } else if (exports.invalidHandler !== false) {
 105           debug("invalid: "+k+"="+val, types[k])
 106         }
 107         return remove
 108       }
 109       debug("validated val", d, val, types[k])
 110       return d[k]
 111     }).filter(function (val) { return val !== remove })
 112
 113     if (!val.length) delete data[k]
 114     else if (isArray) {
 115       debug(isArray, data[k], val)
 116       data[k] = val
 117     } else data[k] = val[0]
 118
 119     debug("k=%s val=%j", k, val, data[k])
 120   })
 121 }
 122
 123 function validateString (data, k, val) {
 124   data[k] = String(val)
 125 }
 126
 127 function validatePath (data, k, val) {
 128   if (val === true) return false
 129   if (val === null) return true
 130
 131   val = String(val)
 132   var homePattern = process.platform === 'win32' ? /^~(\/|\\)/ : /^~\//
 133   if (val.match(homePattern) && process.env.HOME) {
 134     val = path.resolve(process.env.HOME, val.substr(2))
 135   }
 136   data[k] = path.resolve(String(val))
 137   return true
 138 }
 139
 140 function validateNumber (data, k, val) {
 141   debug("validate Number %j %j %j", k, val, isNaN(val))
 142   if (isNaN(val)) return false
 143   data[k] = +val
 144 }
 145
 146 function validateDate (data, k, val) {
 147   debug("validate Date %j %j %j", k, val, Date.parse(val))
 148   var s = Date.parse(val)
 149   if (isNaN(s)) return false
 150   data[k] = new Date(val)
 151 }
 152
 153 function validateBoolean (data, k, val) {
 154   if (val instanceof Boolean) val = val.valueOf()
 155   else if (typeof val === "string") {
 156     if (!isNaN(val)) val = !!(+val)
 157     else if (val === "null" || val === "false") val = false
 158     else val = true
 159   } else val = !!val
 160   data[k] = val
 161 }
 162
 163 function validateUrl (data, k, val) {
 164   val = url.parse(String(val))
 165   if (!val.host) return false
 166   data[k] = val.href
 167 }
 168
 169 function validateStream (data, k, val) {
 170   if (!(val instanceof Stream)) return false
 171   data[k] = val
 172 }
 173
 174 function validate (data, k, val, type, typeDefs) {
 175   // arrays are lists of types.
 176   if (Array.isArray(type)) {
 177     for (var i = 0, l = type.length; i < l; i ++) {
 178       if (type[i] === Array) continue
 179       if (validate(data, k, val, type[i], typeDefs)) return true
 180     }
 181     delete data[k]
 182     return false
 183   }
 184
 185   // an array of anything?
 186   if (type === Array) return true
 187
 188   // NaN is poisonous.  Means that something is not allowed.
 189   if (type !== type) {
 190     debug("Poison NaN", k, val, type)
 191     delete data[k]
 192     return false
 193   }
 194
 195   // explicit list of values
 196   if (val === type) {
 197     debug("Explicitly allowed %j", val)
 198     // if (isArray) (data[k] = data[k] || []).push(val)
 199     // else data[k] = val
 200     data[k] = val
 201     return true
 202   }
 203
 204   // now go through the list of typeDefs, validate against each one.
 205   var ok = false
 206     , types = Object.keys(typeDefs)
 207   for (var i = 0, l = types.length; i < l; i ++) {
 208     debug("test type %j %j %j", k, val, types[i])
 209     var t = typeDefs[types[i]]
 210     if (t &&
 211       ((type && type.name && t.type && t.type.name) ? (type.name === t.type.name) : (type === t.type))) {
 212       var d = {}
 213       ok = false !== t.validate(d, k, val)
 214       val = d[k]
 215       if (ok) {
 216         // if (isArray) (data[k] = data[k] || []).push(val)
 217         // else data[k] = val
 218         data[k] = val
 219         break
 220       }
 221     }
 222   }
 223   debug("OK? %j (%j %j %j)", ok, k, val, types[i])
 224
 225   if (!ok) delete data[k]
 226   return ok
 227 }
 228
 229 function parse (args, data, remain, types, shorthands) {
 230   debug("parse", args, data, remain)
 231
 232   var key = null
 233     , abbrevs = abbrev(Object.keys(types))
 234     , shortAbbr = abbrev(Object.keys(shorthands))
 235
 236   for (var i = 0; i < args.length; i ++) {
 237     var arg = args[i]
 238     debug("arg", arg)
 239
 240     if (arg.match(/^-{2,}$/)) {
 241       // done with keys.
 242       // the rest are args.
 243       remain.push.apply(remain, args.slice(i + 1))
 244       args[i] = "--"
 245       break
 246     }
 247     var hadEq = false
 248     if (arg.charAt(0) === "-" && arg.length > 1) {
 249       if (arg.indexOf("=") !== -1) {
 250         hadEq = true
 251         var v = arg.split("=")
 252         arg = v.shift()
 253         v = v.join("=")
 254         args.splice.apply(args, [i, 1].concat([arg, v]))
 255       }
 256
 257       // see if it's a shorthand
 258       // if so, splice and back up to re-parse it.
 259       var shRes = resolveShort(arg, shorthands, shortAbbr, abbrevs)
 260       debug("arg=%j shRes=%j", arg, shRes)
 261       if (shRes) {
 262         debug(arg, shRes)
 263         args.splice.apply(args, [i, 1].concat(shRes))
 264         if (arg !== shRes[0]) {
 265           i --
 266           continue
 267         }
 268       }
 269       arg = arg.replace(/^-+/, "")
 270       var no = null
 271       while (arg.toLowerCase().indexOf("no-") === 0) {
 272         no = !no
 273         arg = arg.substr(3)
 274       }
 275
 276       if (abbrevs[arg]) arg = abbrevs[arg]
 277
 278       var isArray = types[arg] === Array ||
 279         Array.isArray(types[arg]) && types[arg].indexOf(Array) !== -1
 280
 281       // allow unknown things to be arrays if specified multiple times.
 282       if (!types.hasOwnProperty(arg) && data.hasOwnProperty(arg)) {
 283         if (!Array.isArray(data[arg]))
 284           data[arg] = [data[arg]]
 285         isArray = true
 286       }
 287
 288       var val
 289         , la = args[i + 1]
 290
 291       var isBool = typeof no === 'boolean' ||
 292         types[arg] === Boolean ||
 293         Array.isArray(types[arg]) && types[arg].indexOf(Boolean) !== -1 ||
 294         (typeof types[arg] === 'undefined' && !hadEq) ||
 295         (la === "false" &&
 296          (types[arg] === null ||
 297           Array.isArray(types[arg]) && ~types[arg].indexOf(null)))
 298
 299       if (isBool) {
 300         // just set and move along
 301         val = !no
 302         // however, also support --bool true or --bool false
 303         if (la === "true" || la === "false") {
 304           val = JSON.parse(la)
 305           la = null
 306           if (no) val = !val
 307           i ++
 308         }
 309
 310         // also support "foo":[Boolean, "bar"] and "--foo bar"
 311         if (Array.isArray(types[arg]) && la) {
 312           if (~types[arg].indexOf(la)) {
 313             // an explicit type
 314             val = la
 315             i ++
 316           } else if ( la === "null" && ~types[arg].indexOf(null) ) {
 317             // null allowed
 318             val = null
 319             i ++
 320           } else if ( !la.match(/^-{2,}[^-]/) &&
 321                       !isNaN(la) &&
 322                       ~types[arg].indexOf(Number) ) {
 323             // number
 324             val = +la
 325             i ++
 326           } else if ( !la.match(/^-[^-]/) && ~types[arg].indexOf(String) ) {
 327             // string
 328             val = la
 329             i ++
 330           }
 331         }
 332
 333         if (isArray) (data[arg] = data[arg] || []).push(val)
 334         else data[arg] = val
 335
 336         continue
 337       }
 338
 339       if (types[arg] === String && la === undefined)
 340         la = ""
 341
 342       if (la && la.match(/^-{2,}$/)) {
 343         la = undefined
 344         i --
 345       }
 346
 347       val = la === undefined ? true : la
 348       if (isArray) (data[arg] = data[arg] || []).push(val)
 349       else data[arg] = val
 350
 351       i ++
 352       continue
 353     }
 354     remain.push(arg)
 355   }
 356 }
 357
 358 function resolveShort (arg, shorthands, shortAbbr, abbrevs) {
 359   // handle single-char shorthands glommed together, like
 360   // npm ls -glp, but only if there is one dash, and only if
 361   // all of the chars are single-char shorthands, and it's
 362   // not a match to some other abbrev.
 363   arg = arg.replace(/^-+/, '')
 364
 365   // if it's an exact known option, then don't go any further
 366   if (abbrevs[arg] === arg)
 367     return null
 368
 369   // if it's an exact known shortopt, same deal
 370   if (shorthands[arg]) {
 371     // make it an array, if it's a list of words
 372     if (shorthands[arg] && !Array.isArray(shorthands[arg]))
 373       shorthands[arg] = shorthands[arg].split(/\s+/)
 374
 375     return shorthands[arg]
 376   }
 377
 378   // first check to see if this arg is a set of single-char shorthands
 379   var singles = shorthands.___singles
 380   if (!singles) {
 381     singles = Object.keys(shorthands).filter(function (s) {
 382       return s.length === 1
 383     }).reduce(function (l,r) {
 384       l[r] = true
 385       return l
 386     }, {})
 387     shorthands.___singles = singles
 388     debug('shorthand singles', singles)
 389   }
 390
 391   var chrs = arg.split("").filter(function (c) {
 392     return singles[c]
 393   })
 394
 395   if (chrs.join("") === arg) return chrs.map(function (c) {
 396     return shorthands[c]
 397   }).reduce(function (l, r) {
 398     return l.concat(r)
 399   }, [])
 400
 401
 402   // if it's an arg abbrev, and not a literal shorthand, then prefer the arg
 403   if (abbrevs[arg] && !shorthands[arg])
 404     return null
 405
 406   // if it's an abbr for a shorthand, then use that
 407   if (shortAbbr[arg])
 408     arg = shortAbbr[arg]
 409
 410   // make it an array, if it's a list of words
 411   if (shorthands[arg] && !Array.isArray(shorthands[arg]))
 412     shorthands[arg] = shorthands[arg].split(/\s+/)
 413
 414   return shorthands[arg]
 415 }