Modular options parser allowing plugins to provide everything.
npm install @opt/parseModular options parser allowing plugins to provide everything.
This package doesn't do parsing, it provides the target for plugins to add their stuff.
The expectations are:
1. You will use plugins. If you weren't, you'd just require() your favorite parser.
2. So, you will call parse.use() at least once to load at least one plugin.
3. So, you can specify the plugin providing the options parser as the first param, like: parser.use('some-parser-plugin', 'another-plugin'). For example, use @opt/nopt to use nopt to parse.
The above expectations mean this package doesn't do parsing itself. It has no dependency on a parser package. So, no baggage when requiring different parsers.
``sh`
npm install @opt/parse --save
`javascript
var parse = require('@opt/parse')
// Must provide a plugin with parse implementation. This uses @opt/nopt.
// other plugins are optional. May specify them in separate use() calls.
parse.use('@opt/nopt', '@opt/words', '@opt/require')
// then use parse as you would use nopt,`
// plus any changes made possible by the plugins added
options = parse({}, {}, process.argv, 2)
See @use/core to understand how the use() function behaves.
See real plugins:
1. @opt/nopt
2. @opt/words
3. @opt/require
TODO: Make a plugin to handle type def stuff. It could be parser implementation agnostic. Then, the parser implementation plugins could grab all additional type defs from a standard format.
Example of writing a plugin for @opt/parse:
`javascriptoptions
module.exports = function (options, opt) {
// use to help configure what you're going to donopt
// change for your plugin's interests...
// for example, add to typeDefs like @opt/words does:
var nopt = require('nopt')
nopt.typeDefs.someNewType = {
type: theTypeKey, // used in options spec
validate: function validateThisType(data, key, value) {
// either return false for invalid
// or, return true and optionally change data[key]
}
}
}
``