Merge pull request #15 from choria-io/14

(#14) Expand duration handling

Author: ripienaar

README.md

@@ -28,16 +28,17 @@ Some historical points in time are kept:
  * 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
+ * Extended parsing for durations that include weeks (`w`, `W`), months (`M`), years (`y`, `Y`) and days (`d`, `D`) units
 
-## UnNegatableBool
+### 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
+### 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.
 

app.go

@@ -77,13 +77,13 @@ func New(name, help string) *Application {
 	a.argGroup = newArgGroup()
 	a.cmdGroup = newCmdGroup(a)
 	a.HelpFlag = a.Flag("help", "Show context-sensitive help")
-	a.HelpFlag.Bool()
+	a.HelpFlag.UnNegatableBool()
 
-	a.Flag("help-long", "Generate long help.").Hidden().PreAction(a.generateLongHelp).Bool()
-	a.Flag("help-man", "Generate a man page.").Hidden().PreAction(a.generateManPage).Bool()
-	a.Flag("completion-bash", "Output possible completions for the given args.").Hidden().BoolVar(&a.completion)
-	a.Flag("completion-script-bash", "Generate completion script for bash.").Hidden().PreAction(a.generateBashCompletionScript).Bool()
-	a.Flag("completion-script-zsh", "Generate completion script for ZSH.").Hidden().PreAction(a.generateZSHCompletionScript).Bool()
+	a.Flag("help-long", "Generate long help.").Hidden().PreAction(a.generateLongHelp).UnNegatableBool()
+	a.Flag("help-man", "Generate a man page.").Hidden().PreAction(a.generateManPage).UnNegatableBool()
+	a.Flag("completion-bash", "Output possible completions for the given args.").Hidden().UnNegatableBoolVar(&a.completion)
+	a.Flag("completion-script-bash", "Generate completion script for bash.").Hidden().PreAction(a.generateBashCompletionScript).UnNegatableBool()
+	a.Flag("completion-script-zsh", "Generate completion script for ZSH.").Hidden().PreAction(a.generateZSHCompletionScript).UnNegatableBool()
 
 	return a
 }
@@ -402,7 +402,7 @@ and by saving the output using --save these cheats become accessible within that
 
 See https://github.com/cheat/cheat for more details`)
 	a.CheatCommand.Arg("label", "The cheat to show").StringVar(&cheat)
-	a.CheatCommand.Flag("list", "List available cheats").BoolVar(&list)
+	a.CheatCommand.Flag("list", "List available cheats").UnNegatableBoolVar(&list)
 	a.CheatCommand.Flag("save", "Saves the cheats to the given directory").PlaceHolder("DIRECTORY").StringVar(&dir)
 
 	return a
@@ -445,7 +445,7 @@ func (a *Application) Version(version string) *Application {
 		a.terminate(0)
 		return nil
 	})
-	a.VersionFlag.Bool()
+	a.VersionFlag.UnNegatableBool()
 	return a
 }
 

duration_test.go

@@ -0,0 +1,33 @@
+package fisk
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestDurationParser(t *testing.T) {
+	cases := []struct {
+		s   string
+		d   time.Duration
+		err error
+	}{
+		{"-1m1d", (time.Minute + (24 * time.Hour)) * -1, nil},
+		{"1m1.1w", (184 * time.Hour) + time.Minute, nil},
+		{"1M", 24 * 30 * time.Hour, nil},
+		{"1Y1M", (365 * 24 * time.Hour) + (24 * 30 * time.Hour), nil},
+		{"1xX", 0, fmt.Errorf("%w: invalid unit xX", errInvalidDuration)},
+	}
+
+	for _, c := range cases {
+		d, err := ParseDuration(c.s)
+		if c.err == nil {
+			assert.NoError(t, err)
+		} else {
+			assert.Error(t, err, c.err)
+		}
+		assert.Equal(t, c.d, d, c.s)
+	}
+}

durations.go

@@ -0,0 +1,101 @@
+package fisk
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"time"
+)
+
+var (
+	durationMatcher    = regexp.MustCompile(`([-+]?)(([\d\.]+)([a-zA-Z]+))`)
+	errInvalidDuration = fmt.Errorf("invalid duration")
+)
+
+// ParseDuration parse durations with additional units over those from
+// standard go parser.
+//
+// In addition to normal go parser time units it also supports
+// these.
+//
+// The reason these are not in go standard lib is due to precision around
+// how many days in a month and about leap years and leap seconds. This
+// function does nothing to try and correct for those.
+//
+// * "w", "W" - a week based on 7 days of exactly 24 hours
+// * "d", "D" - a day based on 24 hours
+// * "M" - a month made of 30 days of 24 hours
+// * "y", "Y" - a year made of 365 days of 24 hours each
+//
+// Valid duration strings can be -1y1d1µs
+func ParseDuration(d string) (time.Duration, error) {
+	var (
+		r   time.Duration
+		neg = 1
+	)
+
+	if len(d) == 0 {
+		return r, errInvalidDuration
+	}
+
+	parts := durationMatcher.FindAllStringSubmatch(d, -1)
+	if len(parts) == 0 {
+		return r, errInvalidDuration
+	}
+
+	for i, p := range parts {
+		if len(p) != 5 {
+			return 0, errInvalidDuration
+		}
+
+		if i == 0 && p[1] == "-" {
+			neg = -1
+		}
+
+		switch p[4] {
+		case "w", "W":
+			val, err := strconv.ParseFloat(p[3], 32)
+			if err != nil {
+				return 0, fmt.Errorf("%w: %v", errInvalidDuration, err)
+			}
+
+			r += time.Duration(val*7*24) * time.Hour
+
+		case "d", "D":
+			val, err := strconv.ParseFloat(p[3], 32)
+			if err != nil {
+				return 0, fmt.Errorf("%w: %v", errInvalidDuration, err)
+			}
+
+			r += time.Duration(val*24) * time.Hour
+
+		case "M":
+			val, err := strconv.ParseFloat(p[3], 32)
+			if err != nil {
+				return 0, fmt.Errorf("%w: %v", errInvalidDuration, err)
+			}
+
+			r += time.Duration(val*24*30) * time.Hour
+
+		case "Y", "y":
+			val, err := strconv.ParseFloat(p[3], 32)
+			if err != nil {
+				return 0, fmt.Errorf("%w: %v", errInvalidDuration, err)
+			}
+
+			r += time.Duration(val*24*365) * time.Hour
+
+		case "ns", "us", "µs", "ms", "s", "m", "h":
+			dur, err := time.ParseDuration(p[2])
+			if err != nil {
+				return 0, fmt.Errorf("%w: %v", errInvalidDuration, err)
+			}
+
+			r += dur
+		default:
+			return 0, fmt.Errorf("%w: invalid unit %v", errInvalidDuration, p[4])
+		}
+	}
+
+	return time.Duration(neg) * r, nil
+}

model.go

@@ -35,7 +35,7 @@ func (f *FlagGroupModel) FlagSummary() string {
 
 		if flag.Required {
 			if flag.IsBoolFlag() {
-				if flag.IsNegatable() && flag.Name != "help" && flag.Name != "version" {
+				if flag.IsNegatable() {
 					out = append(out, fmt.Sprintf("--[no-]%s", flag.Name))
 				} else {
 					out = append(out, fmt.Sprintf("--%s=%s", flag.Name, flag.FormatPlaceHolder()))

usage.go

@@ -78,7 +78,7 @@ func formatFlag(haveShort bool, flag *FlagModel) string {
 	flagString := ""
 	flagName := flag.Name
 
-	if flag.IsNegatable() && flag.Name != "help" && flag.Name != "version" {
+	if flag.IsNegatable() {
 		flagName = "[no-]" + flagName
 	}
 

values.go

@@ -156,7 +156,7 @@ func newDurationValue(p *time.Duration) *durationValue {
 }
 
 func (d *durationValue) Set(s string) error {
-	v, err := time.ParseDuration(s)
+	v, err := ParseDuration(s)
 	*d = durationValue(v)
 	return err
 }