"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/nopt/lib/nopt.js" (8 Mar 2017, 11740 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    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 }