Merge pull request #13 from choria-io/12

(#12) Support UnNegatableBool()

Author: ripienaar

README.md

@@ -27,12 +27,21 @@ Some historical points in time are kept:
  * Changes to make `staticcheck` happy
  * A new default template that shortens the help on large apps, old default preserved as `KingpinDefaultUsageTemplate`
  * Integration with [cheat](https://github.com/cheat/cheat) (see [below](#cheats))
+ * Unnegatable booleans using a new `UnNegatableBool()` flag type, backwards compatibility kept
+
+## UnNegatableBool
+
+Fisk will add to all `Bool()` kind flags a negated version, in other words `--force` will also get `--no-force` added
+and the usage will show these negatable booleans.
+
+Often though one does not want to have the negatable version of a boolean added, with fisk you can achieve this using
+our `UnNegatableBool()` which would just be the basic boolean flag with no negatable version.
 
 ## Cheats
 
 I really like [cheat](https://github.com/cheat/cheat), a great little tool that gives access to bite-sized hints on what's great about a CLI tool.
 
-Since `v0.2.0` Fisk supports cheats natively, you can get cheat formatted hints right from the app with no extra dependencies or export cheats into the `cheat` app for use via its interface and integrations.
+Since `v0.1.1` Fisk supports cheats natively, you can get cheat formatted hints right from the app with no extra dependencies or export cheats into the `cheat` app for use via its interface and integrations.
 
 ```nohighlight
 $ nats cheat pub

flags.go

@@ -94,8 +94,12 @@ loop:
 					if strings.HasPrefix(name, "no-") {
 						name = name[3:]
 						invert = true
+						flag, ok = f.long[name]
+						if ok {
+							bf, bok := flag.value.(BoolFlag)
+							ok = bok && bf.BoolFlagIsNegatable()
+						}
 					}
-					flag, ok = f.long[name]
 				}
 				if !ok {
 					return nil, fmt.Errorf("unknown long flag '%s'", flagToken)
@@ -111,8 +115,7 @@ loop:
 
 			flag.isSetByUser()
 
-			fb, ok := flag.value.(boolFlag)
-			if ok && fb.IsBoolFlag() {
+			if isBoolFlag(flag.value) {
 				if invert {
 					defaultValue = "false"
 				} else {

flags_test.go

@@ -1,6 +1,7 @@
 package fisk
 
 import (
+	"bytes"
 	"io/ioutil"
 	"os"
 	"testing"
@@ -389,3 +390,45 @@ func TestIsSetByUser(t *testing.T) {
 	assert.True(t, isSet)
 	assert.False(t, isSet2)
 }
+
+func TestNegatableBool(t *testing.T) {
+	app := newTestApp()
+	boolFlag := app.Flag("neg", "").Bool()
+	unNegBoolFlag := app.Flag("unneg", "").UnNegatableBool()
+
+	_, err := app.Parse([]string{})
+	assert.NoError(t, err)
+	assert.False(t, *unNegBoolFlag)
+	assert.False(t, *boolFlag)
+
+	_, err = app.Parse([]string{"--neg"})
+	assert.NoError(t, err)
+	assert.True(t, *boolFlag)
+	assert.False(t, *unNegBoolFlag)
+
+	_, err = app.Parse([]string{"--no-neg"})
+	assert.NoError(t, err)
+	assert.False(t, *boolFlag)
+	assert.False(t, *unNegBoolFlag)
+
+	_, err = app.Parse([]string{"--unneg"})
+	assert.NoError(t, err)
+	assert.False(t, *boolFlag)
+	assert.True(t, *unNegBoolFlag)
+
+	_, err = app.Parse([]string{"--no-unneg"})
+	assert.Error(t, err, "unknown long flag '--no-unneg'")
+}
+
+func TestHelpForBoolFlags(t *testing.T) {
+	app := newTestApp()
+	app.Flag("yes", "").Default("true").Bool()
+	app.Flag("no", "").Default("false").Bool()
+	app.Flag("nonneg", "").UnNegatableBool()
+
+	w := bytes.NewBuffer(nil)
+	app.Writer(w).Usage(nil)
+	assert.Contains(t, w.String(), "--[no-]yes")
+	assert.Contains(t, w.String(), "--[no-]no")
+	assert.Contains(t, w.String(), "--nonneg")
+}

model.go

@@ -34,10 +34,12 @@ func (f *FlagGroupModel) FlagSummary() string {
 		}
 
 		if flag.Required {
-			if flag.IsBoolFlag() && flag.Name != "help" && flag.Name != "version" {
-				out = append(out, fmt.Sprintf("--[no-]%s", flag.Name))
-			} else {
-				out = append(out, fmt.Sprintf("--%s=%s", flag.Name, flag.FormatPlaceHolder()))
+			if flag.IsBoolFlag() {
+				if flag.IsNegatable() && flag.Name != "help" && flag.Name != "version" {
+					out = append(out, fmt.Sprintf("--[no-]%s", flag.Name))
+				} else {
+					out = append(out, fmt.Sprintf("--%s=%s", flag.Name, flag.FormatPlaceHolder()))
+				}
 			}
 		}
 	}
@@ -67,10 +69,12 @@ func (f *FlagModel) String() string {
 }
 
 func (f *FlagModel) IsBoolFlag() bool {
-	if fl, ok := f.Value.(boolFlag); ok {
-		return fl.IsBoolFlag()
-	}
-	return false
+	return isBoolFlag(f.Value)
+}
+
+func (f *FlagModel) IsNegatable() bool {
+	bf, ok := f.Value.(BoolFlag)
+	return ok && bf.BoolFlagIsNegatable()
 }
 
 func (f *FlagModel) FormatPlaceHolder() string {

parser.go

@@ -199,7 +199,7 @@ func (p *ParseContext) Next() *Token {
 		flag, ok := p.flags.short[short]
 		// Not a known short flag, we'll just return it anyway.
 		if !ok {
-		} else if fb, ok := flag.value.(boolFlag); ok && fb.IsBoolFlag() {
+		} else if isBoolFlag(flag.value) {
 			// Bool short flag.
 		} else {
 			// Short flag with combined argument: -fARG

usage.go

@@ -77,9 +77,11 @@ func formatCmdUsage(app *ApplicationModel, cmd *CmdModel) string {
 func formatFlag(haveShort bool, flag *FlagModel) string {
 	flagString := ""
 	flagName := flag.Name
-	if flag.IsBoolFlag() && flag.Name != "help" && flag.Name != "version" {
+
+	if flag.IsNegatable() && flag.Name != "help" && flag.Name != "version" {
 		flagName = "[no-]" + flagName
 	}
+
 	if flag.Short != 0 {
 		flagString += fmt.Sprintf("-%c, --%s", flag.Short, flagName)
 	} else {

values.go

@@ -128,6 +128,24 @@ func (a *accumulator) IsCumulative() bool {
 	return true
 }
 
+// BoolFlag is an optional interface to specify that a flag is a boolean flag.
+type BoolFlag interface {
+	// BoolFlagIsNegatable Specify if the flag is negatable (ie. supports both --no-<name> and --name).
+	BoolFlagIsNegatable() bool
+}
+
+func isBoolFlag(f Value) bool {
+	if bf, ok := f.(boolFlag); ok {
+		return bf.IsBoolFlag()
+	}
+	_, ok := f.(BoolFlag)
+	return ok
+}
+
+func (b *boolValue) BoolFlagIsNegatable() bool { return true }
+
+func (n *unNegatableBoolValue) BoolFlagIsNegatable() bool { return false }
+
 func (b *boolValue) IsBoolFlag() bool { return true }
 
 // -- time.Duration Value

values.json

@@ -1,5 +1,6 @@
 [
   {"type": "bool", "parser": "strconv.ParseBool(s)"},
+  {"name": "UnNegatableBool", "type": "bool", "parser": "strconv.ParseBool(s)"},
   {"type": "string", "parser": "s, error(nil)", "format": "string(*f.v)", "plural": "Strings"},
   {"type": "uint", "parser": "strconv.ParseUint(s, 0, 64)", "plural": "Uints"},
   {"type": "uint8", "parser": "strconv.ParseUint(s, 0, 8)"},

values_generated.go

@@ -54,6 +54,49 @@ func (p *parserMixin) BoolListVar(target *[]bool) {
 	}))
 }
 
+// -- bool Value
+type unNegatableBoolValue struct{ v *bool }
+
+func newUnNegatableBoolValue(p *bool) *unNegatableBoolValue {
+	return &unNegatableBoolValue{p}
+}
+
+func (f *unNegatableBoolValue) Set(s string) error {
+	v, err := strconv.ParseBool(s)
+	if err == nil {
+		*f.v = (bool)(v)
+	}
+	return err
+}
+
+func (f *unNegatableBoolValue) Get() interface{} { return (bool)(*f.v) }
+
+func (f *unNegatableBoolValue) String() string { return fmt.Sprintf("%v", *f.v) }
+
+// UnNegatableBool parses the next command-line value as bool.
+func (p *parserMixin) UnNegatableBool() (target *bool) {
+	target = new(bool)
+	p.UnNegatableBoolVar(target)
+	return
+}
+
+func (p *parserMixin) UnNegatableBoolVar(target *bool) {
+	p.SetValue(newUnNegatableBoolValue(target))
+}
+
+// UnNegatableBoolList accumulates bool values into a slice.
+func (p *parserMixin) UnNegatableBoolList() (target *[]bool) {
+	target = new([]bool)
+	p.UnNegatableBoolListVar(target)
+	return
+}
+
+func (p *parserMixin) UnNegatableBoolListVar(target *[]bool) {
+	p.SetValue(newAccumulator(target, func(v interface{}) Value {
+		return newUnNegatableBoolValue(v.(*bool))
+	}))
+}
+
 // -- string Value
 type stringValue struct{ v *string }