first commit

cli/options.go

@@ -0,0 +1,109 @@
+package cli
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Options is the resolved configuration: a flat name->value map plus a record
+// of which names were explicitly set (so callers can tell a default from a
+// chosen value). Values are kept as strings end-to-end and converted only at
+// the point of use by the typed getters below.
+type Options struct {
+	vals map[string]string
+	set  map[string]bool
+}
+
+func newOptions() *Options {
+	return &Options{vals: map[string]string{}, set: map[string]bool{}}
+}
+
+// IsSet reports whether name was given on the command line or in the config
+// (as opposed to coming from the built-in default).
+func (o *Options) IsSet(name string) bool { return o.set[name] }
+
+// Str returns the raw string value (empty if unset and no default).
+func (o *Options) Str(name string) string { return o.vals[name] }
+
+// boolWords is the single accepted vocabulary for boolean options, mapping each
+// recognised spelling to its truth value. The Bool reader, truthy, and
+// validate() all consult it, so exactly the words that validate are honoured
+// (no "accepted by the reader but rejected by validate" surprises like --x=on).
+var boolWords = map[string]bool{
+	"true": true, "yes": true, "1": true, "on": true,
+	"false": false, "no": false, "0": false, "off": false,
+}
+
+// boolWord reports a value's truth and whether it is a recognised boolean word.
+func boolWord(s string) (val, ok bool) {
+	val, ok = boolWords[strings.ToLower(strings.TrimSpace(s))]
+	return val, ok
+}
+
+// Bool reports whether the value is a truthy boolean word.
+func (o *Options) Bool(name string) bool {
+	val, _ := boolWord(o.vals[name])
+	return val
+}
+
+// Int returns the value as an int, or 0 if empty/invalid.
+func (o *Options) Int(name string) int { return int(o.Int64(name)) }
+
+// Int64 returns the value as an int64, or 0 if empty/invalid.
+func (o *Options) Int64(name string) int64 {
+	n, _ := strconv.ParseInt(strings.TrimSpace(o.vals[name]), 10, 64)
+	return n
+}
+
+// Float returns the value as a float64, or 0 if empty/invalid.
+func (o *Options) Float(name string) float64 {
+	f, _ := strconv.ParseFloat(strings.TrimSpace(o.vals[name]), 64)
+	return f
+}
+
+// Size returns a byte count parsed from a value like "20M" or "512K".
+func (o *Options) Size(name string) int64 {
+	n, _ := parseSize(o.vals[name])
+	return n
+}
+
+// List returns a repeatable option's accumulated values.
+func (o *Options) List(name string) []string {
+	v := o.vals[name]
+	if v == "" {
+		return nil
+	}
+	return strings.Split(v, "\n")
+}
+
+// parseSize converts a size string into a byte count: the first 'K'/'k' or
+// 'M'/'m' in the string selects the multiplier (1024 or 1024*1024) and
+// everything from that byte on is discarded; with no such unit the whole string
+// is the byte count. There is no gigabyte unit, so "1G" is rejected; "1Mi" and
+// "10MB" are 1M and 10M (the trailing bytes are dropped). An empty string is 0
+// bytes; a negative value is rejected.
+func parseSize(s string) (int64, error) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return 0, nil
+	}
+	mult := int64(1)
+	if i := strings.IndexAny(s, "KkMm"); i >= 0 {
+		if c := s[i]; c == 'M' || c == 'm' {
+			mult = 1 << 20
+		} else {
+			mult = 1 << 10
+		}
+		s = s[:i]
+	}
+	n, err := strconv.ParseInt(strings.TrimSpace(s), 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("bad size %q", s)
+	}
+	// Size parsing rejects negative sizes outright.
+	if n < 0 {
+		return 0, fmt.Errorf("negative size %q", s)
+	}
+	return n * mult, nil
+}