urfave-cli/flag.go

668 lines
15 KiB
Go
Raw Normal View History

2013-07-15 02:16:30 +00:00
package cli
2013-12-07 15:10:04 +00:00
import (
"flag"
"fmt"
"os"
"reflect"
"runtime"
2013-12-07 15:10:04 +00:00
"strconv"
"strings"
2014-08-02 21:32:32 +00:00
"time"
2013-12-07 15:10:04 +00:00
)
2013-07-15 02:16:30 +00:00
const defaultPlaceholder = "value"
// BashCompletionFlag enables bash-completion for all commands and subcommands
var BashCompletionFlag = BoolFlag{
Name: "generate-bash-completion",
Hidden: true,
}
// VersionFlag prints the version for the application
var VersionFlag = BoolFlag{
Name: "version, v",
Usage: "print the version",
}
// HelpFlag prints the help for all commands and subcommands
// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
// unless HideHelp is set to true)
var HelpFlag = BoolFlag{
Name: "help, h",
Usage: "show help",
}
// FlagStringer converts a flag definition to a string. This is used by help
// to display a flag.
var FlagStringer FlagStringFunc = stringifyFlag
2013-11-01 14:31:37 +00:00
// Flag is a common interface related to parsing flags in cli.
// For more advanced flag parsing techniques, it is recommended that
2013-11-01 14:31:37 +00:00
// this interface be implemented.
2013-07-15 02:16:30 +00:00
type Flag interface {
2013-07-19 00:39:42 +00:00
fmt.Stringer
2013-11-01 14:31:37 +00:00
// Apply Flag settings to the given flag set
2013-07-19 00:39:42 +00:00
Apply(*flag.FlagSet)
GetName() string
2013-07-19 00:39:42 +00:00
}
2013-07-20 15:21:20 +00:00
func flagSet(name string, flags []Flag) *flag.FlagSet {
2013-07-24 14:35:45 +00:00
set := flag.NewFlagSet(name, flag.ContinueOnError)
2013-09-24 01:41:31 +00:00
2013-07-19 00:39:42 +00:00
for _, f := range flags {
f.Apply(set)
}
return set
2013-07-15 02:16:30 +00:00
}
2013-11-20 08:05:18 +00:00
func eachName(longName string, fn func(string)) {
parts := strings.Split(longName, ",")
for _, name := range parts {
name = strings.Trim(name, " ")
fn(name)
}
}
2014-04-15 14:16:47 +00:00
// Generic is a generic parseable type identified by a specific flag
type Generic interface {
Set(value string) error
String() string
}
// GenericFlag is the flag type for types implementing Generic
type GenericFlag struct {
Name string
Value Generic
Usage string
EnvVar string
Hidden bool
2014-04-15 14:16:47 +00:00
}
// String returns the string representation of the generic flag to display the
// help text to the user (uses the String() method of the generic flag to show
// the value)
2014-04-15 14:16:47 +00:00
func (f GenericFlag) String() string {
return FlagStringer(f)
}
// Apply takes the flagset and calls Set on the generic flag with the value
// provided by the user for parsing by the flag
2014-04-15 14:16:47 +00:00
func (f GenericFlag) Apply(set *flag.FlagSet) {
val := f.Value
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
val.Set(envVal)
break
}
}
}
2014-04-15 14:16:47 +00:00
eachName(f.Name, func(name string) {
set.Var(f.Value, name, f.Usage)
})
}
// GetName returns the name of a flag.
func (f GenericFlag) GetName() string {
2014-04-15 14:16:47 +00:00
return f.Name
}
2015-06-03 03:51:09 +00:00
// StringSlice is an opaque type for []string to satisfy flag.Value
2013-09-24 01:41:31 +00:00
type StringSlice []string
2015-06-03 03:51:09 +00:00
// Set appends the string value to the list of values
func (f *StringSlice) Set(value string) error {
*f = append(*f, value)
2013-09-24 01:41:31 +00:00
return nil
}
2015-06-03 03:51:09 +00:00
// String returns a readable representation of this value (for usage defaults)
func (f *StringSlice) String() string {
return fmt.Sprintf("%s", *f)
2013-09-24 01:41:31 +00:00
}
2015-06-03 03:51:09 +00:00
// Value returns the slice of strings set by this flag
func (f *StringSlice) Value() []string {
return *f
2013-09-24 01:41:31 +00:00
}
// StringSliceFlag is a string flag that can be specified multiple times on the
2015-06-03 03:51:09 +00:00
// command-line
2013-09-24 01:41:31 +00:00
type StringSliceFlag struct {
Name string
Value *StringSlice
Usage string
EnvVar string
Hidden bool
2013-09-24 01:41:31 +00:00
}
2015-06-03 03:51:09 +00:00
// String returns the usage
2013-09-24 01:41:31 +00:00
func (f StringSliceFlag) String() string {
return FlagStringer(f)
2013-09-24 01:41:31 +00:00
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
2013-09-24 01:41:31 +00:00
func (f StringSliceFlag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
newVal := &StringSlice{}
for _, s := range strings.Split(envVal, ",") {
s = strings.TrimSpace(s)
newVal.Set(s)
}
f.Value = newVal
break
}
}
}
2013-11-20 08:05:18 +00:00
eachName(f.Name, func(name string) {
if f.Value == nil {
f.Value = &StringSlice{}
}
2013-11-18 23:35:23 +00:00
set.Var(f.Value, name, f.Usage)
2013-11-20 08:05:18 +00:00
})
2013-11-18 23:35:23 +00:00
}
// GetName returns the name of a flag.
func (f StringSliceFlag) GetName() string {
2013-11-18 23:35:23 +00:00
return f.Name
2013-09-24 01:41:31 +00:00
}
// IntSlice is an opaque type for []int to satisfy flag.Value
type IntSlice []int
2015-06-03 03:51:09 +00:00
// Set parses the value into an integer and appends it to the list of values
func (f *IntSlice) Set(value string) error {
tmp, err := strconv.Atoi(value)
if err != nil {
return err
}
*f = append(*f, tmp)
return nil
}
2015-06-03 03:51:09 +00:00
// String returns a readable representation of this value (for usage defaults)
func (f *IntSlice) String() string {
return fmt.Sprintf("%d", *f)
}
2015-06-03 03:51:09 +00:00
// Value returns the slice of ints set by this flag
func (f *IntSlice) Value() []int {
return *f
}
2015-06-03 03:51:09 +00:00
// IntSliceFlag is an int flag that can be specified multiple times on the
// command-line
type IntSliceFlag struct {
Name string
Value *IntSlice
Usage string
EnvVar string
Hidden bool
}
2015-06-03 03:51:09 +00:00
// String returns the usage
func (f IntSliceFlag) String() string {
return FlagStringer(f)
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
func (f IntSliceFlag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
newVal := &IntSlice{}
for _, s := range strings.Split(envVal, ",") {
s = strings.TrimSpace(s)
err := newVal.Set(s)
if err != nil {
fmt.Fprintf(ErrWriter, err.Error())
}
}
f.Value = newVal
break
}
}
}
2013-11-20 08:05:18 +00:00
eachName(f.Name, func(name string) {
if f.Value == nil {
f.Value = &IntSlice{}
}
2013-11-18 23:35:23 +00:00
set.Var(f.Value, name, f.Usage)
2013-11-20 08:05:18 +00:00
})
2013-11-18 23:35:23 +00:00
}
// GetName returns the name of the flag.
func (f IntSliceFlag) GetName() string {
2013-11-18 23:35:23 +00:00
return f.Name
}
2015-06-03 03:51:09 +00:00
// BoolFlag is a switch that defaults to false
2013-07-15 02:16:30 +00:00
type BoolFlag struct {
Name string
Usage string
EnvVar string
Destination *bool
Hidden bool
2013-07-19 00:39:42 +00:00
}
2015-06-03 03:51:09 +00:00
// String returns a readable representation of this value (for usage defaults)
2013-07-19 00:39:42 +00:00
func (f BoolFlag) String() string {
return FlagStringer(f)
2013-07-19 00:39:42 +00:00
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
2013-07-19 00:39:42 +00:00
func (f BoolFlag) Apply(set *flag.FlagSet) {
val := false
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
envValBool, err := strconv.ParseBool(envVal)
if err == nil {
val = envValBool
}
break
}
}
}
2013-11-20 08:05:18 +00:00
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.BoolVar(f.Destination, name, val, f.Usage)
return
}
set.Bool(name, val, f.Usage)
2013-11-20 08:05:18 +00:00
})
2013-11-18 23:35:23 +00:00
}
// GetName returns the name of the flag.
func (f BoolFlag) GetName() string {
2013-11-18 23:35:23 +00:00
return f.Name
2013-07-15 02:16:30 +00:00
}
2015-06-03 03:51:09 +00:00
// BoolTFlag this represents a boolean flag that is true by default, but can
// still be set to false by --some-flag=false
type BoolTFlag struct {
Name string
Usage string
EnvVar string
Destination *bool
Hidden bool
}
2015-06-03 03:51:09 +00:00
// String returns a readable representation of this value (for usage defaults)
func (f BoolTFlag) String() string {
return FlagStringer(f)
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
func (f BoolTFlag) Apply(set *flag.FlagSet) {
val := true
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
envValBool, err := strconv.ParseBool(envVal)
if err == nil {
val = envValBool
break
}
}
}
}
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.BoolVar(f.Destination, name, val, f.Usage)
return
}
set.Bool(name, val, f.Usage)
})
}
// GetName returns the name of the flag.
func (f BoolTFlag) GetName() string {
return f.Name
}
2015-06-03 03:51:09 +00:00
// StringFlag represents a flag that takes as string value
2013-07-15 02:16:30 +00:00
type StringFlag struct {
Name string
Value string
Usage string
EnvVar string
Destination *string
Hidden bool
2013-07-15 02:16:30 +00:00
}
2015-06-03 03:51:09 +00:00
// String returns the usage
2013-07-15 02:16:30 +00:00
func (f StringFlag) String() string {
return FlagStringer(f)
}
2014-04-11 19:09:59 +00:00
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
2013-07-17 02:59:04 +00:00
func (f StringFlag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
f.Value = envVal
break
}
}
}
2013-11-20 08:05:18 +00:00
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.StringVar(f.Destination, name, f.Value, f.Usage)
return
}
2013-11-18 23:35:23 +00:00
set.String(name, f.Value, f.Usage)
2013-11-20 08:05:18 +00:00
})
2013-11-18 23:35:23 +00:00
}
// GetName returns the name of the flag.
func (f StringFlag) GetName() string {
2013-11-18 23:35:23 +00:00
return f.Name
2013-07-17 02:59:04 +00:00
}
2015-06-03 03:51:09 +00:00
// IntFlag is a flag that takes an integer
// Errors if the value provided cannot be parsed
2013-07-19 00:39:42 +00:00
type IntFlag struct {
Name string
Value int
Usage string
EnvVar string
Destination *int
Hidden bool
2013-07-15 02:16:30 +00:00
}
2013-07-17 02:59:04 +00:00
2015-06-03 03:51:09 +00:00
// String returns the usage
2013-07-19 00:39:42 +00:00
func (f IntFlag) String() string {
return FlagStringer(f)
2013-07-17 02:59:04 +00:00
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
2013-07-19 00:39:42 +00:00
func (f IntFlag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
envValInt, err := strconv.ParseInt(envVal, 0, 64)
if err == nil {
f.Value = int(envValInt)
break
}
}
}
}
2013-11-20 08:05:18 +00:00
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.IntVar(f.Destination, name, f.Value, f.Usage)
return
}
2013-11-18 23:35:23 +00:00
set.Int(name, f.Value, f.Usage)
2013-11-20 08:05:18 +00:00
})
2013-11-18 23:35:23 +00:00
}
// GetName returns the name of the flag.
func (f IntFlag) GetName() string {
2013-11-18 23:35:23 +00:00
return f.Name
2013-07-17 02:59:04 +00:00
}
2013-07-24 14:35:45 +00:00
2015-06-03 03:51:09 +00:00
// DurationFlag is a flag that takes a duration specified in Go's duration
// format: https://golang.org/pkg/time/#ParseDuration
2014-08-02 21:32:32 +00:00
type DurationFlag struct {
Name string
Value time.Duration
Usage string
EnvVar string
Destination *time.Duration
Hidden bool
2014-08-02 21:32:32 +00:00
}
2015-06-03 03:51:09 +00:00
// String returns a readable representation of this value (for usage defaults)
2014-08-02 21:32:32 +00:00
func (f DurationFlag) String() string {
return FlagStringer(f)
2014-08-02 21:32:32 +00:00
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
2014-08-02 21:32:32 +00:00
func (f DurationFlag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
envValDuration, err := time.ParseDuration(envVal)
if err == nil {
f.Value = envValDuration
break
}
2014-08-02 21:32:32 +00:00
}
}
}
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.DurationVar(f.Destination, name, f.Value, f.Usage)
return
}
2014-08-02 21:32:32 +00:00
set.Duration(name, f.Value, f.Usage)
})
}
// GetName returns the name of the flag.
func (f DurationFlag) GetName() string {
2014-08-02 21:32:32 +00:00
return f.Name
}
2015-06-03 03:51:09 +00:00
// Float64Flag is a flag that takes an float value
// Errors if the value provided cannot be parsed
2013-12-03 13:42:09 +00:00
type Float64Flag struct {
Name string
Value float64
Usage string
EnvVar string
Destination *float64
Hidden bool
2013-12-03 13:42:09 +00:00
}
2015-06-03 03:51:09 +00:00
// String returns the usage
2013-12-03 13:42:09 +00:00
func (f Float64Flag) String() string {
return FlagStringer(f)
2013-12-03 13:42:09 +00:00
}
2015-06-03 03:51:09 +00:00
// Apply populates the flag given the flag set and environment
2013-12-03 13:42:09 +00:00
func (f Float64Flag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
envValFloat, err := strconv.ParseFloat(envVal, 10)
if err == nil {
f.Value = float64(envValFloat)
}
}
}
}
2013-12-03 13:42:09 +00:00
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.Float64Var(f.Destination, name, f.Value, f.Usage)
return
}
2013-12-03 13:42:09 +00:00
set.Float64(name, f.Value, f.Usage)
})
}
// GetName returns the name of the flag.
func (f Float64Flag) GetName() string {
2013-12-03 13:42:09 +00:00
return f.Name
}
func visibleFlags(fl []Flag) []Flag {
visible := []Flag{}
for _, flag := range fl {
if !flagValue(flag).FieldByName("Hidden").Bool() {
visible = append(visible, flag)
}
}
return visible
}
2013-09-09 18:51:46 +00:00
func prefixFor(name string) (prefix string) {
if len(name) == 1 {
prefix = "-"
} else {
prefix = "--"
}
return
}
2013-11-20 08:05:18 +00:00
// Returns the placeholder, if any, and the unquoted usage string.
func unquoteUsage(usage string) (string, string) {
for i := 0; i < len(usage); i++ {
if usage[i] == '`' {
for j := i + 1; j < len(usage); j++ {
if usage[j] == '`' {
name := usage[i+1 : j]
usage = usage[:i] + name + usage[j+1:]
return name, usage
}
}
break
}
}
return "", usage
}
func prefixedNames(fullName, placeholder string) string {
var prefixed string
2013-11-20 08:05:18 +00:00
parts := strings.Split(fullName, ",")
for i, name := range parts {
name = strings.Trim(name, " ")
prefixed += prefixFor(name) + name
if placeholder != "" {
prefixed += " " + placeholder
}
2013-11-21 01:25:13 +00:00
if i < len(parts)-1 {
2013-11-20 08:05:18 +00:00
prefixed += ", "
}
}
return prefixed
2013-11-20 08:05:18 +00:00
}
func withEnvHint(envVar, str string) string {
envText := ""
if envVar != "" {
prefix := "$"
suffix := ""
sep := ", $"
if runtime.GOOS == "windows" {
prefix = "%"
suffix = "%"
sep = "%, %"
}
envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(strings.Split(envVar, ","), sep), suffix)
}
return str + envText
}
func flagValue(f Flag) reflect.Value {
fv := reflect.ValueOf(f)
for fv.Kind() == reflect.Ptr {
fv = reflect.Indirect(fv)
}
return fv
}
func stringifyFlag(f Flag) string {
fv := flagValue(f)
switch f.(type) {
case IntSliceFlag:
return withEnvHint(fv.FieldByName("EnvVar").String(),
stringifyIntSliceFlag(f.(IntSliceFlag)))
case StringSliceFlag:
return withEnvHint(fv.FieldByName("EnvVar").String(),
stringifyStringSliceFlag(f.(StringSliceFlag)))
}
placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
needsPlaceholder := false
defaultValueString := ""
val := fv.FieldByName("Value")
if val.IsValid() {
needsPlaceholder = true
defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
if val.Kind() == reflect.String && val.String() != "" {
defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
}
}
if defaultValueString == " (default: )" {
defaultValueString = ""
}
if needsPlaceholder && placeholder == "" {
placeholder = defaultPlaceholder
}
usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString))
return withEnvHint(fv.FieldByName("EnvVar").String(),
fmt.Sprintf("%s\t%s", prefixedNames(fv.FieldByName("Name").String(), placeholder), usageWithDefault))
}
func stringifyIntSliceFlag(f IntSliceFlag) string {
defaultVals := []string{}
if f.Value != nil && len(f.Value.Value()) > 0 {
for _, i := range f.Value.Value() {
defaultVals = append(defaultVals, fmt.Sprintf("%d", i))
}
}
return stringifySliceFlag(f.Usage, f.Name, defaultVals)
}
func stringifyStringSliceFlag(f StringSliceFlag) string {
defaultVals := []string{}
if f.Value != nil && len(f.Value.Value()) > 0 {
for _, s := range f.Value.Value() {
if len(s) > 0 {
defaultVals = append(defaultVals, fmt.Sprintf("%q", s))
}
}
}
return stringifySliceFlag(f.Usage, f.Name, defaultVals)
}
func stringifySliceFlag(usage, name string, defaultVals []string) string {
placeholder, usage := unquoteUsage(usage)
if placeholder == "" {
placeholder = defaultPlaceholder
}
defaultVal := ""
if len(defaultVals) > 0 {
defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
}
usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
2016-05-02 23:52:39 +00:00
return fmt.Sprintf("%s\t%s", prefixedNames(name, placeholder), usageWithDefault)
}