fix: trying to fix #34 again (#35)

Author: egoist

src/CAC.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events'
 import path from 'path'
-import mri, { Options as MriOpts } from 'mri'
+import mri from 'mri'
 import Command, {
   GlobalCommand,
   CommandConfig,
@@ -165,8 +165,7 @@ class CAC extends EventEmitter {
 
     // Search sub-commands
     for (const command of this.commands) {
-      const mriOptions = getMriOptions(this.globalCommand, command)
-      const mriResult = this.mri(argv.slice(2), mriOptions)
+      const mriResult = this.mri(argv.slice(2), command)
 
       const commandName = mriResult.args[0]
       if (command.isMatched(commandName)) {
@@ -185,17 +184,15 @@ class CAC extends EventEmitter {
       for (const command of this.commands) {
         if (command.name === '') {
           shouldParse = false
-          const mriOptions = getMriOptions(this.globalCommand, command)
-          const mriResult = this.mri(argv.slice(2), mriOptions)
+          const mriResult = this.mri(argv.slice(2), command)
           this.setParsedInfo(mriResult, command)
           this.emit(`command:!`, command)
         }
       }
     }
 
     if (shouldParse) {
-      const globalMriOptions = getMriOptions(this.globalCommand)
-      const mriResult = this.mri(argv.slice(2), globalMriOptions)
+      const mriResult = this.mri(argv.slice(2))
       this.setParsedInfo(mriResult)
     }
 
@@ -224,13 +221,25 @@ class CAC extends EventEmitter {
     return parsedArgv
   }
 
-  private mri(argv: string[], mriOptions: MriOpts): MriResult {
+  private mri(
+    argv: string[],
+    /** Matched command */ command?: Command
+  ): MriResult {
+    // All added options
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...(command ? command.options : [])
+    ]
+    const mriOptions = getMriOptions(cliOptions)
+
+    // Extract everything after `--` since mri doesn't support it
     let argsAfterDoubleDashes: string[] = []
     const doubleDashesIndex = argv.indexOf('--')
     if (doubleDashesIndex > -1) {
       argsAfterDoubleDashes = argv.slice(0, doubleDashesIndex)
       argv = argv.slice(doubleDashesIndex + 1)
     }
+
     const parsed = mri(argv, mriOptions)
 
     const args = parsed._
@@ -239,6 +248,24 @@ class CAC extends EventEmitter {
     const options: { [k: string]: any } = {
       '--': argsAfterDoubleDashes
     }
+
+    // Set option default value
+    const ignoreDefault =
+      command && command.config.ignoreOptionDefaultValue
+        ? command.config.ignoreOptionDefaultValue
+        : this.globalCommand.config.ignoreOptionDefaultValue
+
+    if (!ignoreDefault) {
+      for (const cliOption of cliOptions) {
+        if (cliOption.config.default !== undefined) {
+          for (const name of cliOption.names) {
+            options[name] = cliOption.config.default
+          }
+        }
+      }
+    }
+
+    // Camelcase option names and set dot nested option values
     for (const key of Object.keys(parsed)) {
       const keys = key.split('.').map((v, i) => {
         return i === 0 ? camelcase(v) : v

src/Option.ts

@@ -11,6 +11,7 @@ export default class Option {
   // `required` will be a boolean for options with brackets
   required?: boolean
   config: OptionConfig
+  negated?: boolean
 
   constructor(
     public rawName: string,
@@ -19,18 +20,18 @@ export default class Option {
   ) {
     this.config = Object.assign({}, config)
 
-    let negated = false
     this.names = removeBrackets(rawName)
       .split(',')
       .map((v: string) => {
         let name = v.trim().replace(/^-{1,2}/, '')
         if (name.startsWith('no-')) {
-          negated = true
+          this.negated = true
           name = name.replace(/^no-/, '')
         }
         return name
       })
-    if (negated) {
+
+    if (this.negated) {
       this.config.default = true
     }
 

src/__test__/index.test.ts

@@ -53,9 +53,9 @@ test('negated option', () => {
 
   cli.option('--foo [foo]', 'Set foo').option('--no-foo', 'Disable foo')
 
-  cli.option('--no-bar', 'Disable bar')
+  cli.option('--bar [bar]', 'Set bar').option('--no-bar', 'Disable bar')
 
-  const { options } = cli.parse(['node', 'bin', '--foo', 'foo'])
+  const { options } = cli.parse(['node', 'bin', '--foo', 'foo', '--bar'])
   expect(options).toEqual({
     '--': [],
     foo: 'foo',

src/utils.ts

@@ -1,4 +1,4 @@
-import Command from './Command'
+import Option from './Option'
 
 export const removeBrackets = (v: string) => v.replace(/[<[].+/, '').trim()
 
@@ -35,43 +35,47 @@ export const findAllBrackets = (v: string) => {
   return res
 }
 
-export const getMriOptions = (globalCommand: Command, subCommand?: Command) => {
-  const options = [
-    ...globalCommand.options,
-    ...(subCommand ? subCommand.options : [])
-  ]
-  const ignoreDefault =
-    subCommand && subCommand.config.ignoreOptionDefaultValue
-      ? subCommand.config.ignoreOptionDefaultValue
-      : globalCommand.config.ignoreOptionDefaultValue
-  return {
-    default: ignoreDefault
-      ? {}
-      : options.reduce((res: { [k: string]: any }, option) => {
-          if (option.config.default !== undefined) {
-            // Only need to set the default value of the first name
-            // Since mri will automatically do the rest for alias names
-            res[option.names[0]] = option.config.default
-          }
-          return res
-        }, {}),
-    boolean: options
-      .filter(option => option.isBoolean)
-      .reduce((res: string[], option) => {
-        return res.concat(option.names)
-      }, []),
-    alias: options.reduce((res: { [k: string]: string[] }, option) => {
-      if (option.names.length > 1) {
-        res[option.names[0]] = option.names.slice(1)
+interface MriOptions {
+  alias: {
+    [k: string]: string[]
+  }
+  boolean: string[]
+}
+
+export const getMriOptions = (options: Option[]) => {
+  const result: MriOptions = { alias: {}, boolean: [] }
+
+  for (const [index, option] of options.entries()) {
+    // We do not set default values in mri options
+    // Since its type (typeof) will be used to cast parsed arguments.
+    // Which mean `--foo foo` will be parsed as `{foo: true}` if we have `{default:{foo: true}}`
+
+    // Set alias
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1)
+    }
+    // Set boolean
+    if (option.isBoolean) {
+      if (option.negated) {
+        // For negated option
+        // We only set it to `boolean` type when there's no string-type option with the same name
+        const hasStringTypeOption = options.some((o, i) => {
+          return (
+            i !== index &&
+            o.names.some(name => option.names.includes(name)) &&
+            typeof o.required === 'boolean'
+          )
+        })
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0])
+        }
+      } else {
+        result.boolean.push(option.names[0])
       }
-      return res
-    }, {}),
-    string: options
-      .filter(option => typeof option.required === 'boolean')
-      .reduce((res: string[], option) => {
-        return res.concat(option.names)
-      }, [])
+    }
   }
+
+  return result
 }
 
 export const findLongest = (arr: string[]) => {