UNPKG

15 kBMarkdownView Raw
1# Optionator
2<a name="optionator" />
3
4Optionator is a JavaScript/Node.js option parsing and help generation library used by [eslint](http://eslint.org), [Grasp](http://graspjs.com), [LiveScript](http://livescript.net), [esmangle](https://github.com/estools/esmangle), [escodegen](https://github.com/estools/escodegen), and [many more](https://www.npmjs.com/browse/depended/optionator).
5
6For an online demo, check out the [Grasp online demo](http://www.graspjs.com/#demo).
7
8[About](#about) &middot; [Usage](#usage) &middot; [Settings Format](#settings-format) &middot; [Argument Format](#argument-format)
9
10## Why?
11The problem with other option parsers, such as `yargs` or `minimist`, is they just accept all input, valid or not.
12With Optionator, if you mistype an option, it will give you an error (with a suggestion for what you meant).
13If you give the wrong type of argument for an option, it will give you an error rather than supplying the wrong input to your application.
14
15 $ cmd --halp
16 Invalid option '--halp' - perhaps you meant '--help'?
17
18 $ cmd --count str
19 Invalid value for option 'count' - expected type Int, received value: str.
20
21Other helpful features include reformatting the help text based on the size of the console, so that it fits even if the console is narrow, and accepting not just an array (eg. process.argv), but a string or object as well, making things like testing much easier.
22
23## About
24Optionator uses [type-check](https://github.com/gkz/type-check) and [levn](https://github.com/gkz/levn) behind the scenes to cast and verify input according the specified types.
25
26MIT license. Version 0.9.1
27
28 npm install optionator
29
30For updates on Optionator, [follow me on twitter](https://twitter.com/gkzahariev).
31
32Optionator is a Node.js module, but can be used in the browser as well if packed with webpack/browserify.
33
34## Usage
35`require('optionator');` returns a function. It has one property, `VERSION`, the current version of the library as a string. This function is called with an object specifying your options and other information, see the [settings format section](#settings-format). This in turn returns an object with three properties, `parse`, `parseArgv`, `generateHelp`, and `generateHelpForOption`, which are all functions.
36
37```js
38var optionator = require('optionator')({
39 prepend: 'Usage: cmd [options]',
40 append: 'Version 1.0.0',
41 options: [{
42 option: 'help',
43 alias: 'h',
44 type: 'Boolean',
45 description: 'displays help'
46 }, {
47 option: 'count',
48 alias: 'c',
49 type: 'Int',
50 description: 'number of things',
51 example: 'cmd --count 2'
52 }]
53});
54
55var options = optionator.parseArgv(process.argv);
56if (options.help) {
57 console.log(optionator.generateHelp());
58}
59...
60```
61
62### parse(input, parseOptions)
63`parse` processes the `input` according to your settings, and returns an object with the results.
64
65##### arguments
66* input - `[String] | Object | String` - the input you wish to parse
67* parseOptions - `{slice: Int}` - all options optional
68 - `slice` specifies how much to slice away from the beginning if the input is an array or string - by default `0` for string, `2` for array (works with `process.argv`)
69
70##### returns
71`Object` - the parsed options, each key is a camelCase version of the option name (specified in dash-case), and each value is the processed value for that option. Positional values are in an array under the `_` key.
72
73##### example
74```js
75parse(['node', 't.js', '--count', '2', 'positional']); // {count: 2, _: ['positional']}
76parse('--count 2 positional'); // {count: 2, _: ['positional']}
77parse({count: 2, _:['positional']}); // {count: 2, _: ['positional']}
78```
79
80### parseArgv(input)
81`parseArgv` works exactly like `parse`, but only for array input and it slices off the first two elements.
82
83##### arguments
84* input - `[String]` - the input you wish to parse
85
86##### returns
87See "returns" section in "parse"
88
89##### example
90```js
91parseArgv(process.argv);
92```
93
94### generateHelp(helpOptions)
95`generateHelp` produces help text based on your settings.
96
97##### arguments
98* helpOptions - `{showHidden: Boolean, interpolate: Object}` - all options optional
99 - `showHidden` specifies whether to show options with `hidden: true` specified, by default it is `false`
100 - `interpolate` specify data to be interpolated in `prepend` and `append` text, `{{key}}` is the format - eg. `generateHelp({interpolate:{version: '0.4.2'}})`, will change this `append` text: `Version {{version}}` to `Version 0.4.2`
101
102##### returns
103`String` - the generated help text
104
105##### example
106```js
107generateHelp(); /*
108"Usage: cmd [options] positional
109
110 -h, --help displays help
111 -c, --count Int number of things
112
113Version 1.0.0
114"*/
115```
116
117### generateHelpForOption(optionName)
118`generateHelpForOption` produces expanded help text for the specified with `optionName` option. If an `example` was specified for the option, it will be displayed, and if a `longDescription` was specified, it will display that instead of the `description`.
119
120##### arguments
121* optionName - `String` - the name of the option to display
122
123##### returns
124`String` - the generated help text for the option
125
126##### example
127```js
128generateHelpForOption('count'); /*
129"-c, --count Int
130description: number of things
131example: cmd --count 2
132"*/
133```
134
135## Settings Format
136When your `require('optionator')`, you get a function that takes in a settings object. This object has the type:
137
138 {
139 prepend: String,
140 append: String,
141 options: [{heading: String} | {
142 option: String,
143 alias: [String] | String,
144 type: String,
145 enum: [String],
146 default: String,
147 restPositional: Boolean,
148 required: Boolean,
149 overrideRequired: Boolean,
150 dependsOn: [String] | String,
151 concatRepeatedArrays: Boolean | (Boolean, Object),
152 mergeRepeatedObjects: Boolean,
153 description: String,
154 longDescription: String,
155 example: [String] | String
156 }],
157 helpStyle: {
158 aliasSeparator: String,
159 typeSeparator: String,
160 descriptionSeparator: String,
161 initialIndent: Int,
162 secondaryIndent: Int,
163 maxPadFactor: Number
164 },
165 mutuallyExclusive: [[String | [String]]],
166 concatRepeatedArrays: Boolean | (Boolean, Object), // deprecated, set in defaults object
167 mergeRepeatedObjects: Boolean, // deprecated, set in defaults object
168 positionalAnywhere: Boolean,
169 typeAliases: Object,
170 defaults: Object
171 }
172
173All of the properties are optional (the `Maybe` has been excluded for brevities sake), except for having either `heading: String` or `option: String` in each object in the `options` array.
174
175### Top Level Properties
176* `prepend` is an optional string to be placed before the options in the help text
177* `append` is an optional string to be placed after the options in the help text
178* `options` is a required array specifying your options and headings, the options and headings will be displayed in the order specified
179* `helpStyle` is an optional object which enables you to change the default appearance of some aspects of the help text
180* `mutuallyExclusive` is an optional array of arrays of either strings or arrays of strings. The top level array is a list of rules, each rule is a list of elements - each element can be either a string (the name of an option), or a list of strings (a group of option names) - there will be an error if more than one element is present
181* `concatRepeatedArrays` see description under the "Option Properties" heading - use at the top level is deprecated, if you want to set this for all options, use the `defaults` property
182* `mergeRepeatedObjects` see description under the "Option Properties" heading - use at the top level is deprecated, if you want to set this for all options, use the `defaults` property
183* `positionalAnywhere` is an optional boolean (defaults to `true`) - when `true` it allows positional arguments anywhere, when `false`, all arguments after the first positional one are taken to be positional as well, even if they look like a flag. For example, with `positionalAnywhere: false`, the arguments `--flag --boom 12 --crack` would have two positional arguments: `12` and `--crack`
184* `typeAliases` is an optional object, it allows you to set aliases for types, eg. `{Path: 'String'}` would allow you to use the type `Path` as an alias for the type `String`
185* `defaults` is an optional object following the option properties format, which specifies default values for all options. A default will be overridden if manually set. For example, you can do `default: { type: "String" }` to set the default type of all options to `String`, and then override that default in an individual option by setting the `type` property
186
187#### Heading Properties
188* `heading` a required string, the name of the heading
189
190#### Option Properties
191* `option` the required name of the option - use dash-case, without the leading dashes
192* `alias` is an optional string or array of strings which specify any aliases for the option
193* `type` is a required string in the [type check](https://github.com/gkz/type-check) [format](https://github.com/gkz/type-check#type-format), this will be used to cast the inputted value and validate it
194* `enum` is an optional array of strings, each string will be parsed by [levn](https://github.com/gkz/levn) - the argument value must be one of the resulting values - each potential value must validate against the specified `type`
195* `default` is a optional string, which will be parsed by [levn](https://github.com/gkz/levn) and used as the default value if none is set - the value must validate against the specified `type`
196* `restPositional` is an optional boolean - if set to `true`, everything after the option will be taken to be a positional argument, even if it looks like a named argument
197* `required` is an optional boolean - if set to `true`, the option parsing will fail if the option is not defined
198* `overrideRequired` is a optional boolean - if set to `true` and the option is used, and there is another option which is required but not set, it will override the need for the required option and there will be no error - this is useful if you have required options and want to use `--help` or `--version` flags
199* `concatRepeatedArrays` is an optional boolean or tuple with boolean and options object (defaults to `false`) - when set to `true` and an option contains an array value and is repeated, the subsequent values for the flag will be appended rather than overwriting the original value - eg. option `g` of type `[String]`: `-g a -g b -g c,d` will result in `['a','b','c','d']`
200
201 You can supply an options object by giving the following value: `[true, options]`. The one currently supported option is `oneValuePerFlag`, this only allows one array value per flag. This is useful if your potential values contain a comma.
202* `mergeRepeatedObjects` is an optional boolean (defaults to `false`) - when set to `true` and an option contains an object value and is repeated, the subsequent values for the flag will be merged rather than overwriting the original value - eg. option `g` of type `Object`: `-g a:1 -g b:2 -g c:3,d:4` will result in `{a: 1, b: 2, c: 3, d: 4}`
203* `dependsOn` is an optional string or array of strings - if simply a string (the name of another option), it will make sure that that other option is set, if an array of strings, depending on whether `'and'` or `'or'` is first, it will either check whether all (`['and', 'option-a', 'option-b']`), or at least one (`['or', 'option-a', 'option-b']`) other options are set
204* `description` is an optional string, which will be displayed next to the option in the help text
205* `longDescription` is an optional string, it will be displayed instead of the `description` when `generateHelpForOption` is used
206* `example` is an optional string or array of strings with example(s) for the option - these will be displayed when `generateHelpForOption` is used
207
208#### Help Style Properties
209* `aliasSeparator` is an optional string, separates multiple names from each other - default: ' ,'
210* `typeSeparator` is an optional string, separates the type from the names - default: ' '
211* `descriptionSeparator` is an optional string , separates the description from the padded name and type - default: ' '
212* `initialIndent` is an optional int - the amount of indent for options - default: 2
213* `secondaryIndent` is an optional int - the amount of indent if wrapped fully (in addition to the initial indent) - default: 4
214* `maxPadFactor` is an optional number - affects the default level of padding for the names/type, it is multiplied by the average of the length of the names/type - default: 1.5
215
216## Argument Format
217At the highest level there are two types of arguments: named, and positional.
218
219Name arguments of any length are prefixed with `--` (eg. `--go`), and those of one character may be prefixed with either `--` or `-` (eg. `-g`).
220
221There are two types of named arguments: boolean flags (eg. `--problemo`, `-p`) which take no value and result in a `true` if they are present, the falsey `undefined` if they are not present, or `false` if present and explicitly prefixed with `no` (eg. `--no-problemo`). Named arguments with values (eg. `--tseries 800`, `-t 800`) are the other type. If the option has a type `Boolean` it will automatically be made into a boolean flag. Any other type results in a named argument that takes a value.
222
223For more information about how to properly set types to get the value you want, take a look at the [type check](https://github.com/gkz/type-check) and [levn](https://github.com/gkz/levn) pages.
224
225You can group single character arguments that use a single `-`, however all except the last must be boolean flags (which take no value). The last may be a boolean flag, or an argument which takes a value - eg. `-ba 2` is equivalent to `-b -a 2`.
226
227Positional arguments are all those values which do not fall under the above - they can be anywhere, not just at the end. For example, in `cmd -b one -a 2 two` where `b` is a boolean flag, and `a` has the type `Number`, there are two positional arguments, `one` and `two`.
228
229Everything after an `--` is positional, even if it looks like a named argument.
230
231You may optionally use `=` to separate option names from values, for example: `--count=2`.
232
233If you specify the option `NUM`, then any argument using a single `-` followed by a number will be valid and will set the value of `NUM`. Eg. `-2` will be parsed into `NUM: 2`.
234
235If duplicate named arguments are present, the last one will be taken.
236
237## Technical About
238`optionator` is written in [LiveScript](http://livescript.net/) - a language that compiles to JavaScript. It uses [levn](https://github.com/gkz/levn) to cast arguments to their specified type, and uses [type-check](https://github.com/gkz/type-check) to validate values. It also uses the [prelude.ls](http://preludels.com/) library.