feat: Implicit boolean option (#109)

Implicit boolean option support

A option which doesn't take a value is called as an implicit boolean
option.

A typical implicit boolean option is defined like below:

```
program
  .command('command', 'Command')
  .option('-f, --flag', 'Flag')
  ...
```

The default value of any implicit boolean option is always `true` even
though a value other than `false` is explicitly specified as its
default value.

There is no meaning to specify arguments other than `synopsis` and
`description`.  Because:

* `validator`: The option has no value to be validate
* `defaultValue`: The default value is always `false`
* `required`: Setting it `true` always makes the option value `true`

lib/autocomplete.js

@@ -181,9 +181,9 @@ class Autocomplete {
   }
 
   _complete(data, done) {
-    const args = parseArgs(data.args.slice(1));
+    const currCommand = this._findCommand(data.args.slice(3).join(' '));
+    const args = parseArgs(data.args.slice(1), currCommand ? currCommand.parseArgsOpts : {});
     const cmd = args._.join(' ');
-    const currCommand = this._findCommand(cmd);
 
 
 

lib/command.js

@@ -36,6 +36,7 @@ class Command extends GetterSetter {
     this._lastAddedArgOrOpt = null;
     this._visible = true;
     this._setupLoggerMethods();
+    this.parseArgsOpts = { boolean: [] };
   }
 
 
@@ -376,6 +377,9 @@ class Command extends GetterSetter {
     const opt = new Option(synopsis, description, validator, defaultValue, required, this._program);
     this._lastAddedArgOrOpt = opt;
     this._options.push(opt);
+    if (opt.isImplicitBoolean()) {
+      this.parseArgsOpts.boolean.push(opt.getLongOrShortName());
+    }
     return this;
   }
 

lib/option.js

@@ -36,6 +36,8 @@ class Option extends GetterSetter {
     this._long = analysis.long;
     this._booleanFlag = analysis.booleanFlag;
     this._name = this.getCleanNameFromNotation(this._longCleanName || this._shortCleanName);
+    if (this.isImplicitBoolean())
+      this._default = false;
   }
 
   hasDefault() {
@@ -46,6 +48,10 @@ class Option extends GetterSetter {
     return this._validator ? this._validator.getChoices() : [];
   }
 
+  isImplicitBoolean() {
+    return this._valueType === undefined;
+  }
+
   isRequired() {
     return this._required;
   }

lib/program.js

@@ -262,7 +262,10 @@ class Program extends GetterSetter {
    */
   parse(argv) {
     const argvSlice = argv.slice(2);
-    const args = parseArgs(argv);
+    let cmd = this._commands.filter(c => (c.name() === argvSlice[0] || c.getAlias() === argvSlice[0]))[0];
+    if (!cmd)
+      cmd = this._getDefaultCommand(false);
+    const args = parseArgs(argv, cmd ? cmd.parseArgsOpts : {});
     let options = Object.assign({}, args);
     delete options._;
 

package.json

@@ -62,7 +62,7 @@
     "lodash.camelcase": "^4.3.0",
     "lodash.kebabcase": "^4.1.1",
     "lodash.merge": "^4.6.0",
-    "micromist": "^1.0.1",
+    "micromist": "1.1.0",
     "prettyjson": "^1.2.1",
     "tabtab": "^2.2.2",
     "winston": "^2.3.1"

tests/issues/issue-107-implicit-boolean-option.js

@@ -0,0 +1,128 @@
+"use strict";
+
+/* global Program, logger, should, makeArgv, sinon */
+
+describe('Issue #107 - Implicit boolean option', () => {
+  context('having the shorthand and the longhand', () => {
+    beforeEach(() => {
+      this.program = new Program();
+      this.action = sinon.spy();
+      this.program
+        .logger(logger)
+        .version('1.0.0')
+        .command('cmd', 'Command')
+        .option('-b, --bool', 'Implicit boolean')
+        .argument('[a]', 'A', this.program.INT)
+        .action(this.action);
+      this.fatalError = sinon.stub(this.program, "fatalError");
+    });
+
+    afterEach(() => {
+      this.fatalError.restore();
+      this.program.reset();
+    });
+
+    it(`should call the action with {a: 1} and {bool: true}`, () => {
+      this.program.parse(makeArgv(['cmd', '-b', '1']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({a: 1}, {bool: true}, logger));
+    });
+
+    it(`should call the action with {} and {bool: true}`, () => {
+      this.program.parse(makeArgv(['cmd', '-b']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({}, {bool: true}, logger));
+    });
+
+    it(`should call the action with {a: 1} and {bool: false}`, () => {
+      this.program.parse(makeArgv(['cmd', '1']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({a: 1}, {bool: false}, logger));
+    });
+  });
+
+  context('only having the longhand', () => {
+    beforeEach(() => {
+      this.program = new Program();
+      this.action = sinon.spy();
+      this.program
+        .logger(logger)
+        .version('1.0.0')
+        .command('cmd', 'Command')
+        .option('--bool', 'Implicit boolean')
+        .argument('[a]', 'A', this.program.INT)
+        .action(this.action);
+      this.fatalError = sinon.stub(this.program, "fatalError");
+    });
+
+    afterEach(() => {
+      this.fatalError.restore();
+      this.program.reset();
+    });
+
+    it(`should call the action with {a: 1} and {bool: true}`, () => {
+      this.program.parse(makeArgv(['cmd', '--bool', '1']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({a: 1}, {bool: true}, logger));
+    });
+
+    it(`should call the action with {} and {bool: true}`, () => {
+      this.program.parse(makeArgv(['cmd', '--bool']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({}, {bool: true}, logger));
+    });
+
+    it(`should call the action with {a: 1} and {bool: false}`, () => {
+      this.program.parse(makeArgv(['cmd', '1']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({a: 1}, {bool: false}, logger));
+    });
+  });
+
+  context('only having the shorthand', () => {
+    beforeEach(() => {
+      this.program = new Program();
+      this.action = sinon.spy();
+      this.program
+        .logger(logger)
+        .version('1.0.0')
+        .command('cmd', 'Command')
+        .option('-b', 'Implicit boolean')
+        .argument('[a]', 'A', this.program.INT)
+        .action(this.action);
+      this.fatalError = sinon.stub(this.program, "fatalError");
+    });
+
+    afterEach(() => {
+      this.fatalError.restore();
+      this.program.reset();
+    });
+
+    it(`should call the action with {a: 1} and {b: true}`, () => {
+      this.program.parse(makeArgv(['cmd', '-b', '1']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({a: 1}, {b: true}, logger));
+    });
+
+    it(`should call the action with {} and {b: true}`, () => {
+      this.program.parse(makeArgv(['cmd', '-b']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({}, {b: true}, logger));
+    });
+
+    it(`should call the action with {a: 1} and {b: false}`, () => {
+      this.program.parse(makeArgv(['cmd', '1']));
+      should(this.fatalError.callCount).eql(0);
+      should(this.action.callCount).eql(1);
+      should(this.action.calledWith({a: 1}, {b: false}, logger));
+    });
+  });
+});