varflag

package
v0.12.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 3, 2024 License: Apache-2.0 Imports: 12 Imported by: 0

README

varflag

Package flag implements command-line flag parsing into vars.Variables for easy type handling with additional flag types.

PkgGoDev license GitHub last commit tests Go Report Card Coverage Status

Flags

note that major version ensures compatibility with https://github.com/happy-sdk/vars package

go get github.com/happy-sdk/happy-go/varflag

String flag

package main

import (
  "fmt"
  "log"
  "os"
  "github.com/happy-sdk/happy-go/varflag"
)

func main() {
  os.Args = []string{"/bin/app", "--str", "some value"}
  // create flag named string with default value "default str"
  // and aditional aliases for this flag
  str, err := varflag.New("string", "default str", "some string", "s", "str")
  if err != nil {
    log.Println(err)
    return
  }
  found, err := str.Parse(os.Args)
  if err != nil {
    log.Println(err)
    return
  }
  fmt.Printf("%-12s%s\n", "name", str.Name())
  fmt.Printf("%-12s%s\n", "flag", str.Flag())
  fmt.Printf("%-12s%t\n", "found", found)
  fmt.Printf("%-12s%s\n", "value", str.Value())
  // all flags satisfy Stringer interface
  fmt.Printf("%-12s%s\n", "string", str.String())
  fmt.Printf("%-12s%s\n", "default", str.Default())
  fmt.Printf("%-12s%s\n", "usage", str.Usage())
  fmt.Printf("%-12s%s\n", "aliases-str", str.AliasesString())
  fmt.Printf("%-12s%#v\n", "aliases", str.Aliases())
  // You can mark flag as hidden by calling .Hide()
  // Helpful when you are composing help menu.
  fmt.Printf("%-12s%t\n", "is:hidden", str.IsHidden())
  // by default flag is global regardless which position it was found.
  // You can mark flag non global by calling .BelongsTo(cmdname string).
  fmt.Printf("%-12s%t\n", "is:global", str.IsGlobal())
  fmt.Printf("%-12s%q\n", "command", str.CommandName())
  fmt.Printf("%-12s%d\n", "position", str.Pos())
  fmt.Printf("%-12s%t\n", "present", str.Present())
  // Var is underlying vars.Variable for convinient type conversion
  fmt.Printf("%-12s%s\n", "var", str.Var())
  // you can set flag as required by calling Required before you parse flags.
  fmt.Printf("%-12s%t\n", "required", str.IsRequired())
  // Output:
  // name        string
  // flag        --string
  // found       true
  // value       some value
  // string      some value
  // default     default str
  // usage       some string - default: "default str"
  // aliases-str -s,--str
  // aliases     []string{"s", "str"}
  // is:hidden   false
  // is:global   true
  // command     ""
  // position    2
  // present     true
  // var         some value
  // required    false
}

Duration flag

os.Args = []string{"/bin/app", "--duration", "1h30s"}
dur, _ := varflag.Duration("duration", 1*time.Second, "")
dur.Parse(os.Args)

fmt.Printf("%-12s%d\n", "duration", dur.Value())
fmt.Printf("%-12s%s\n", "duration", dur.Value())
fmt.Printf("%-12s%s\n", "string", dur.String())
fmt.Printf("%-12s%d\n", "int", dur.Var().Int())
fmt.Printf("%-12s%d\n", "int64", dur.Var().Int64())
fmt.Printf("%-12s%d\n", "uint", dur.Var().Uint())
fmt.Printf("%-12s%d\n", "uint64", dur.Var().Uint64())
fmt.Printf("%-12s%f\n", "float64", dur.Var().Float64())
// Output:
// duration    3630000000000
// duration    1h0m30s
// string      1h0m30s
// int         3630000000000
// int64       3630000000000
// uint        3630000000000
// uint64      3630000000000
// float64     3630000000000.000000

Float flag

os.Args = []string{"/bin/app", "--float", "1.001000023"}
f, _ := varflag.Float64("float", 1.0, "")
f.Parse(os.Args)

fmt.Printf("%-12s%.10f\n", "float", f.Value())
fmt.Printf("%-12s%s\n", "string", f.String())
fmt.Printf("%-12s%.10f\n", "float32", f.Var().Float32())
fmt.Printf("%-12s%.10f\n", "float64", f.Var().Float64())
// Output:
// float       1.0010000230
// string      1.001000023
// float32     1.0010000467
// float64     1.0010000230

Int flag

os.Args = []string{"/bin/app", "--int", fmt.Sprint(math.MinInt64), "int64"}
f, _ := varflag.Int("int", 1, "")
f.Parse(os.Args)

fmt.Printf("%-12s%s\n", "string", f.String())
fmt.Printf("%-12s%d\n", "value", f.Value())
fmt.Printf("%-12s%d\n", "int", f.Var().Int())
fmt.Printf("%-12s%d\n", "int64", f.Var().Int64())
fmt.Printf("%-12s%d\n", "uint", f.Var().Uint())
fmt.Printf("%-12s%d\n", "uint64", f.Var().Uint64())
fmt.Printf("%-12s%f\n", "float32", f.Var().Float32())
fmt.Printf("%-12s%f\n", "float64", f.Var().Float64())
// Output:
// string      -9223372036854775808
// value       -9223372036854775808
// int         -9223372036854775808
// int64       -9223372036854775808
// uint        0
// uint64      0
// float32     -9223372036854775808.000000
// float64     -9223372036854775808.000000

Uint Flag

os.Args = []string{"/bin/app", "--uint", strconv.FormatUint(math.MaxUint64, 10), "uint64"}
f, _ := varflag.Uint("uint", 1, "")
f.Parse(os.Args)

fmt.Printf("%-12s%s\n", "string", f.String())
fmt.Printf("%-12s%d\n", "value", f.Value())
fmt.Printf("%-12s%d\n", "int", f.Var().Int())
fmt.Printf("%-12s%d\n", "int64", f.Var().Int64())
fmt.Printf("%-12s%d\n", "uint", f.Var().Uint())
fmt.Printf("%-12s%d\n", "uint64", f.Var().Uint64())
fmt.Printf("%-12s%f\n", "float32", f.Var().Float32())
fmt.Printf("%-12s%f\n", "float64", f.Var().Float64())
// Output:
// string      18446744073709551615
// value       18446744073709551615
// int         9223372036854775807
// int64       9223372036854775807
// uint        18446744073709551615
// uint64      18446744073709551615
// float32     18446744073709551616.000000
// float64     18446744073709551616.000000
}

Bool Flag

Valid bool flag args are

true

--bool, --bool=true, --bool=1 --bool=on, --bool true, --bool 1, --bool on

false

--bool, --bool=false, --bool=0 --bool=off, --bool false, --bool 0, --bool off

os.Args = []string{"/bin/app", "--bool"}
f, _ := varflag.Bool("bool", false, "")
f.Parse(os.Args)

fmt.Printf("%-12s%s\n", "string", f.String())
fmt.Printf("%-12s%t\n", "value", f.Value())
fmt.Printf("%-12s%t\n", "bool", f.Var().Bool())
// Output:
// string      true
// value       true
// bool        true

Option Flag

os.Args = []string{"/bin/app", "--option", "opt1", "--option", "opt2"}
f, _ := varflag.Option("option", []string{"defaultOpt"}, "", []string{"opt1", "opt2", "opt3", "defaultOpt"})
f.Parse(os.Args)

fmt.Printf("%-12s%s\n", "string", f.String())
fmt.Printf("%-12s%#v\n", "value", f.Value())

// Output:
// string      opt1|opt2
// value       []string{"opt1", "opt2"}

Bash Brace Expansion Flag

uses githubc.com/happy-sdk/bexp for Brace Expansion

os.Args = []string{"/bin/app", "--images", "image-{0..2}.jpg"}
f, _ := varflag.Bexp("images", "image-{a,b,c}.jpg", "expand path", "")
f.Parse(os.Args)

fmt.Printf("%-12s%s\n", "string", f.String())
fmt.Printf("%-12s%#v\n", "value", f.Value())

// Output:
// string      image-0.jpg|image-1.jpg|image-2.jpg
// value       []string{"image-0.jpg", "image-1.jpg", "image-2.jpg"}

Parsing

Parse individual flags

str1, _ := varflag.New("str1", ".", "some string")
str2, _ := varflag.New("str2", "", "some other string")

str1.Parse(os.Args)
str2.Parse(os.Args)

Parse all flags at once

var flags []varflag.Flag

str1, _ := varflag.New("str1", ".", "some string")
str2, _ := varflag.New("str2", "", "some other string")

flags = append(flags, srt1, srt2)
varflag.Parse(flags, os.Args)

Use flag set

str1, err := varflag.New("str1", "", "")
str2, err := varflag.New("str2", "", "")
flags,err := varflag.NewFlagSet("/", 0)
flags.Add(str1, str2)
err := flags.Parse(os.Args)

test

golangci-lint run --config=./.github/golangci.yaml --fix
go test -race -covermode atomic  .

Documentation

Overview

Package varflag implements command-line flag parsing into compatible with package https://github.com/happy-sdk/happy/pkg/vars.

Originally based of https://pkg.go.dev/github.com/mkungla/varflag/v5

Index

Constants

View Source 
const (
	// FlagRe check flag name against following expression.
	FlagRe = "^[a-z][a-z0-9_-]*[a-z0-9]$"
)

Variables

View Source 
var (
	// ErrFlag is returned when flag fails to initialize.
	ErrFlag = errors.New("flag error")
	// ErrFlag is returned when flag fails to initialize.
	ErrFlagExists = errors.New("flag already exists")
	// ErrParse is used to indicate parse errors.
	ErrParse = errors.New("flag parse error")
	// ErrMissingValue is used when flag value was not in parsed args.
	ErrMissingValue = errors.New("missing value for flag")
	// ErrInvalidValue is used when invalid value was provided.
	ErrInvalidValue = errors.New("invalid value for flag")
	// ErrFlagAlreadyParsed is returned when this flag was already parsed.
	ErrFlagAlreadyParsed = errors.New("flag is already parsed")
	// ErrMissingRequired indicates that required flag was not in argument set.
	ErrMissingRequired = errors.New("missing required flag")
	// ErrMissingOptions is returned when option flag parser does not find options.
	ErrMissingOptions = errors.New("missing options")
	// ErrNoNamedFlag is returned when flag lookup can not find named flag.
	ErrNoNamedFlag      = errors.New("no such flag")
	ErrInvalidArguments = errors.New("invalid arguments")
)
View Source 
var ErrInvalidFlagSetName = errors.New("invalid flag set name")

Functions

func AsFlag 

func AsFlag[
	FLAG FlagIface[VAR, VAL],
	VAR vars.VariableIface[VAL],
	VAL vars.ValueIface,
](in Flag) FLAG

func NewFlagSetAs 

func NewFlagSetAs[
	FLAGS FlagsIface[FLAGSET, FLAG, VAR, VAL],
	FLAGSET FlagsSetIface[FLAG, VAR, VAL],
	FLAG FlagIface[VAR, VAL],
	VAR vars.VariableIface[VAL],
	VAL vars.ValueIface,
](name string, argsn int) (FLAGS, error)

NewFlagSet is wrapper to parse flags together. e.g. under specific command. Where "name" is command name to search before parsing the flags under this set. argsn is number of command line arguments allowed within this set. If argsn is -gt 0 then parser will stop after finding argsn+1 argument which is not a flag.

func Parse 

func Parse(flags []Flag, args []string) error

Parse parses flags against provided args, If one of the flags fails to parse, it will return error.

func SetArgcMax added in v0.6.0 

func SetArgcMax(flags Flags, max int) error

func ValidFlagName 

func ValidFlagName(s string) bool

ValidFlagName returns true if s is string which is valid flag name.

Types

type BexpFlag 

type BexpFlag struct {
	Common
	// contains filtered or unexported fields
}

BexpFlag expands flag args with bash brace expansion.

func Bexp 

func Bexp(name string, value string, usage string, aliases ...string) (flag *BexpFlag, err error)

Bexp returns new Bash Brace Expansion flag.

func (*BexpFlag) Parse 

func (f *BexpFlag) Parse(args []string) (ok bool, err error)

Parse BexpFlag.

func (*BexpFlag) Unset 

func (f *BexpFlag) Unset()

Unset the int flag value.

func (*BexpFlag) Value 

func (f *BexpFlag) Value() []string

Value returns parsed options.

type BoolFlag 

type BoolFlag struct {
	Common
	// contains filtered or unexported fields
}

BoolFlag is boolean flag type with default value "false".

func Bool 

func Bool(name string, value bool, usage string, aliases ...string) (flag *BoolFlag, err error)

Bool returns new bool flag. Argument "a" can be any nr of aliases.

func (*BoolFlag) Parse 

func (f *BoolFlag) Parse(args []string) (bool, error)

Parse bool flag.

func (*BoolFlag) Unset 

func (f *BoolFlag) Unset()

Unset the bool flag value.

func (*BoolFlag) Value 

func (f *BoolFlag) Value() bool

Value returns bool flag value, it returns default value if not present or false if default is also not set.

type Common 

type Common struct {
	// contains filtered or unexported fields
}

Common is default string flag. Common flag ccan be used to as base for custom flags by owerriding .Parse func.

func New 

func New(name string, value string, usage string, aliases ...string) (*Common, error)

New returns new common string flag. Argument "a" can be any nr of aliases.

func (*Common) Aliases 

func (f *Common) Aliases() []string

Aliases returns all aliases for the flag together with primary "name".

func (*Common) AttachTo 

func (f *Common) AttachTo(cmdname string)

AttachTo marks flag non global and belonging to provided named command. Parsing the flag will only succeed if naemd command was found before the flag. This is useful to have same flag both global and sub command level. Special case is .BelongsTo("*") which marks flag to be parsed if any subcommand is present. e.g. verbose flag: you can define 2 BoolFlag's with name "verbose" and alias "v" and mark one of these with BelongsTo("*"). BelongsTo(os.Args[0] | "/") are same as global and will be.

func (*Common) BelongsTo 

func (f *Common) BelongsTo() string

CommandName returns empty string if command is not set with .BelongsTo When BelongsTo is set to wildcard "*" then this function will return name of the command which triggered this flag to be parsed.

func (*Common) Default 

func (f *Common) Default() vars.Variable

Default sets flag default.

func (*Common) Flag 

func (f *Common) Flag() string

Flag returns flag with leading - or --.

func (*Common) Global 

func (f *Common) Global() bool

IsGlobal reports whether this flag is global. By default all flags are global flags. You can mark flag non-global by calling .BelongsTo(cmdname string).

func (*Common) Hidden 

func (f *Common) Hidden() bool

IsHidden reports whether flag should be visible in help menu.

func (*Common) Hide 

func (f *Common) Hide()

Hide flag from help menu.

func (*Common) Input 

func (f *Common) Input() []string

func (*Common) MarkAsRequired 

func (f *Common) MarkAsRequired()

Required sets this flag as required.

func (*Common) Name 

func (f *Common) Name() string

Name returns primary name for the flag usually that is long option.

func (*Common) Parse 

func (f *Common) Parse(args []string) (bool, error)

Parse the StringFlag.

func (*Common) Pos 

func (f *Common) Pos() int

Pos returns flags position after command and case of global since app name min value is 1 which means first global flag or first flag after command.

func (*Common) Present 

func (f *Common) Present() bool

Present reports whether flag was set in commandline.

func (*Common) Required 

func (f *Common) Required() bool

IsRequired returns true if this flag is required.

func (*Common) String 

func (f *Common) String() string

String calls Value().String().

func (*Common) Unset 

func (f *Common) Unset()

Unset the value.

func (*Common) Usage 

func (f *Common) Usage() string

Usage returns a usage description for that flag.

func (*Common) UsageAliases 

func (f *Common) UsageAliases() string

UsageAliases returns string representing flag aliases. e.g. used in help menu.

func (*Common) Value 

func (f *Common) Value() string

Value returns string value of flag.

func (*Common) Var 

func (f *Common) Var() vars.Variable

V returns vars.Variable for this flag. where key is flag and Value flags value.

type DurationFlag added in v0.10.0 

type DurationFlag struct {
	Common
	// contains filtered or unexported fields
}

func Duration added in v0.10.0 

func Duration(name string, value time.Duration, usage string, aliases ...string) (flag *DurationFlag, err error)

func (*DurationFlag) Parse added in v0.10.0 

func (f *DurationFlag) Parse(args []string) (bool, error)

type Flag 

type Flag interface {
	// Get primary name for the flag. Usually that is long option
	Name() string

	// Get flag default value
	Default() vars.Variable

	// Usage returns a usage description for that flag
	Usage() string

	// Flag returns flag with leading - or --
	// useful for help menus
	Flag() string

	// Return flag aliases
	Aliases() []string
	UsageAliases() string

	// IsHidden reports whether to show that flag in help menu or not.
	Hidden() bool

	// Hide flag from help menu.
	Hide()

	// IsGlobal reports whether this flag was global and was set before any command or arg
	Global() bool

	// BelongsTo marks flag non global and belonging to provided named command.
	AttachTo(cmdname string)
	// BelongsTo returns empty string if command is not set with .AttachTo
	// When AttachTo is set to wildcard "*" then this function will return
	// name of the command which triggered this flag to be parsed.
	BelongsTo() string

	// Pos returns flags position after command. In case of mulyflag first position is reported
	Pos() int
	// Unset unsets the value for the flag if it was parsed, handy for cases where
	// one flag cancels another like --debug cancels --verbose
	Unset()

	// Present reports whether flag was set in commandline
	Present() bool

	// Var returns vars.Variable for this flag.
	// where key is flag and Value flags value.
	Var() vars.Variable

	// Required sets this flag as required
	MarkAsRequired()

	// IsRequired returns true if this flag is required
	Required() bool

	// Parse value for the flag from given string. It returns true if flag
	// was found in provided args string and false if not.
	// error is returned when flag was set but had invalid value.
	Parse([]string) (bool, error)

	// String calls Value().String()
	String() string

	Input() []string
}

Flag is howi/cli/flags.Flags interface.

type FlagCreateFunc 

type FlagCreateFunc func() (Flag, error)

func BoolFunc 

func BoolFunc(name string, value bool, usage string, aliases ...string) FlagCreateFunc

func DurationFunc added in v0.10.0 

func DurationFunc(name string, value time.Duration, usage string, aliases ...string) FlagCreateFunc

func Float64Func 

func Float64Func(name string, value float64, usage string, aliases ...string) FlagCreateFunc

func IntFunc 

func IntFunc(name string, value int, usage string, aliases ...string) FlagCreateFunc

func OptionFunc 

func OptionFunc(name string, value []string, opts []string, usage string, aliases ...string) FlagCreateFunc

func StringFunc added in v0.7.0 

func StringFunc(name string, value string, usage string, aliases ...string) FlagCreateFunc

func UintFunc 

func UintFunc(name string, value uint, usage string, aliases ...string) FlagCreateFunc

type FlagIface 

type FlagIface[VAR vars.VariableIface[VAL], VAL vars.ValueIface] interface {
	Name() string
	Default() VAR
	Usage() string
	Flag() string
	Aliases() []string
	UsageAliases() string
	Hidden() bool
	Hide()
	Global() bool
	AttachTo(cmdname string)
	BelongsTo() string
	Pos() int
	Unset()
	Present() bool
	Var() VAR
	MarkAsRequired()
	Required() bool
	Parse([]string) (bool, error)
	Input() []string
}

type FlagSet 

type FlagSet struct {
	// contains filtered or unexported fields
}

FlagSet holds collection of flags for parsing e.g. global, sub command or custom flag collection.

func NewFlagSet 

func NewFlagSet(name string, argn int) (*FlagSet, error)

NewFlagSet is wrapper to parse flags together. e.g. under specific command. Where "name" is command name to search before parsing the flags under this set. argsn is number of command line arguments allowed within this set. If argsn is -gt 0 then parser will stop after finding argsn+1 argument which is not a flag.

func (*FlagSet) AcceptsArgs 

func (s *FlagSet) AcceptsArgs() bool

Args returns parsed arguments for this flag set.

func (*FlagSet) Add 

func (s *FlagSet) Add(flag ...Flag) error

Add flag to flag set.

func (*FlagSet) AddSet 

func (s *FlagSet) AddSet(set ...Flags) error

AddSet adds flag set.

func (*FlagSet) Args 

func (s *FlagSet) Args() []vars.Value

Args returns parsed arguments for this flag set.

func (*FlagSet) Flags 

func (s *FlagSet) Flags() []Flag

Flags returns slice of flags in this set.

func (*FlagSet) Get 

func (s *FlagSet) Get(name string) (Flag, error)

Get flag of current set.

func (*FlagSet) GetActiveSets 

func (s *FlagSet) GetActiveSets() []Flags

GetSetTree

func (*FlagSet) Len 

func (s *FlagSet) Len() int

Len returns nuber of flags in set.

func (*FlagSet) Name 

func (s *FlagSet) Name() string

Name returns name of the flag set.

func (*FlagSet) Parse 

func (s *FlagSet) Parse(args []string) error

Parse all flags recursively.

func (*FlagSet) Pos 

func (s *FlagSet) Pos() int

Pos returns flagset position from it's parent.

func (*FlagSet) Present 

func (s *FlagSet) Present() bool

Present returns true if this set was parsed.

func (*FlagSet) Sets 

func (s *FlagSet) Sets() []Flags

Sets retruns subsets of flags under this flagset.

type Flags 

type Flags interface {
	// Name of the flag set
	Name() string

	// Len returns number of flags in this set
	// not including subset flags.
	Len() int

	// Add flag to flag set
	Add(...Flag) error

	// Get named flag
	Get(name string) (Flag, error)

	// Add sub set of flags to flag set
	AddSet(...Flags) error

	// GetActiveSets.
	GetActiveSets() []Flags

	// Position of flag set
	Pos() int

	// Was flagset (sub command present)
	Present() bool

	Args() []vars.Value

	// AcceptsArgs returns true if set accepts any arguments.
	AcceptsArgs() bool

	// Flags returns slice of flags in this set
	Flags() []Flag

	// Sets retruns subsets of flags under this flagset.
	Sets() []Flags

	// Parse all flags and sub sets
	Parse(args []string) error
}

Flags provides interface for flag set.

type FlagsIface 

type FlagsIface[
	FLAGS FlagsSetIface[FLAG, VAR, VAL],
	FLAG FlagIface[VAR, VAL],
	VAR vars.VariableIface[VAL],
	VAL vars.ValueIface,
] interface {
	FlagsSetIface[FLAG, VAR, VAL]
	GetActiveSets() []FLAGS
	Sets() []FLAGS
}

type FlagsSetIface 

type FlagsSetIface[
	FLAG FlagIface[VAR, VAL],
	VAR vars.VariableIface[VAL],
	VAL vars.ValueIface,
] interface {
	Name() string
	Add(flag ...FLAG) error
	Get(name string) (FLAG, error)
	Args() []VAL
	Flags() []FLAG
	Present() bool
	Parse(args []string) error
}

type Float64Flag 

type Float64Flag struct {
	Common
	// contains filtered or unexported fields
}

Float64Flag defines a float64 flag with specified name.

func Float64 

func Float64(name string, value float64, usage string, aliases ...string) (flag *Float64Flag, err error)

Float64 returns new float flag. Argument "a" can be any nr of aliases.

func (*Float64Flag) Parse 

func (f *Float64Flag) Parse(args []string) (bool, error)

Parse float flag.

func (*Float64Flag) Unset 

func (f *Float64Flag) Unset()

Unset the bool flag value.

func (*Float64Flag) Value 

func (f *Float64Flag) Value() float64

Value return float64 flag value, it returns default value if not present or 0 if default is also not set.

type GenericFlag 

type GenericFlag[VAR vars.VariableIface[VAL], VAL vars.ValueIface] struct {
	// contains filtered or unexported fields
}

func (*GenericFlag[VAR, VAL]) Aliases 

func (f *GenericFlag[VAR, VAL]) Aliases() []string

Return flag aliases

func (*GenericFlag[VAR, VAL]) AttachTo 

func (f *GenericFlag[VAR, VAL]) AttachTo(cmdname string)

BelongsTo marks flag non global and belonging to provided named command.

func (*GenericFlag[VAR, VAL]) BelongsTo 

func (f *GenericFlag[VAR, VAL]) BelongsTo() string

BelongsTo returns empty string if command is not set with .BelongsTo When BelongsTo is set to wildcard "*" then this function will return name of the command which triggered this flag to be parsed.

func (*GenericFlag[VAR, VAL]) Default 

func (f *GenericFlag[VAR, VAL]) Default() VAR

func (*GenericFlag[VAR, VAL]) Flag 

func (f *GenericFlag[VAR, VAL]) Flag() string

Flag returns flag with leading - or -- useful for help menus

func (*GenericFlag[VAR, VAL]) Global 

func (f *GenericFlag[VAR, VAL]) Global() bool

IsGlobal reports whether this flag was global and was set before any command or arg

func (*GenericFlag[VAR, VAL]) Hidden 

func (f *GenericFlag[VAR, VAL]) Hidden() bool

IsHidden reports whether to show that flag in help menu or not.

func (*GenericFlag[VAR, VAL]) Hide 

func (f *GenericFlag[VAR, VAL]) Hide()

Hide flag from help menu.

func (*GenericFlag[VAR, VAL]) Input 

func (f *GenericFlag[VAR, VAL]) Input() []string

func (*GenericFlag[VAR, VAL]) MarkAsRequired 

func (f *GenericFlag[VAR, VAL]) MarkAsRequired()

Required sets this flag as required

func (*GenericFlag[VAR, VAL]) Name 

func (f *GenericFlag[VAR, VAL]) Name() string

Get primary name for the flag. Usually that is long option

func (*GenericFlag[VAR, VAL]) Parse 

func (f *GenericFlag[VAR, VAL]) Parse(args []string) (bool, error)

Parse value for the flag from given string. It returns true if flag was found in provided args string and false if not. error is returned when flag was set but had invalid value.

func (*GenericFlag[VAR, VAL]) Pos 

func (f *GenericFlag[VAR, VAL]) Pos() int

Pos returns flags position after command. In case of mulyflag first position is reported

func (*GenericFlag[VAR, VAL]) Present 

func (f *GenericFlag[VAR, VAL]) Present() bool

Present reports whether flag was set in commandline

func (*GenericFlag[VAR, VAL]) Required 

func (f *GenericFlag[VAR, VAL]) Required() bool

IsRequired returns true if this flag is required

func (*GenericFlag[VAR, VAL]) String 

func (f *GenericFlag[VAR, VAL]) String() string

String calls Value().String()

func (*GenericFlag[VAR, VAL]) Unset 

func (f *GenericFlag[VAR, VAL]) Unset()

Unset unsets the value for the flag if it was parsed, handy for cases where one flag cancels another like --debug cancels --verbose

func (*GenericFlag[VAR, VAL]) Usage 

func (f *GenericFlag[VAR, VAL]) Usage() string

Usage returns a usage description for that flag

func (*GenericFlag[VAR, VAL]) UsageAliases 

func (f *GenericFlag[VAR, VAL]) UsageAliases() string

func (*GenericFlag[VAR, VAL]) Var 

func (f *GenericFlag[VAR, VAL]) Var() (v VAR)

type GenericFlagSet 

type GenericFlagSet[
	FLAGS FlagsIface[FLAGSET, FLAG, VAR, VAL],
	FLAGSET FlagsSetIface[FLAG, VAR, VAL],
	FLAG FlagIface[VAR, VAL],
	VAR vars.VariableIface[VAL],
	VAL vars.ValueIface,
] struct {
	// contains filtered or unexported fields
}

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) AcceptsArgs 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) AcceptsArgs() bool

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Add 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Add(flag ...FLAG) error

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) AddSet 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) AddSet(set ...FLAGS) error

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Args 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Args() []VAL

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Flags 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Flags() []FLAG

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Get 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Get(name string) (f FLAG, err error)

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) GetActiveSets 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) GetActiveSets() []FLAGSET

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Len 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Len() int

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Name 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Name() string

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Parse 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Parse(args []string) error

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Pos 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Pos() int

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Present 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Present() bool

func (*GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Sets 

func (s *GenericFlagSet[FLAGS, FLAGSET, FLAG, VAR, VAL]) Sets() []FLAGSET

type IntFlag 

type IntFlag struct {
	Common
	// contains filtered or unexported fields
}

IntFlag defines an int flag with specified name,.

func Int 

func Int(name string, value int, usage string, aliases ...string) (flag *IntFlag, err error)

Int returns new int flag. Argument "a" can be any nr of aliases.

func (*IntFlag) Parse 

func (f *IntFlag) Parse(args []string) (bool, error)

Parse int flag.

func (*IntFlag) Unset 

func (f *IntFlag) Unset()

Unset the int flag value.

func (*IntFlag) Value 

func (f *IntFlag) Value() int

Value returns int flag value, it returns default value if not present or 0 if default is also not set.

type OptionFlag 

type OptionFlag struct {
	Common
	// contains filtered or unexported fields
}

OptionFlag is string flag type which can have value of one of the options.

func Option 

func Option(name string, value []string, opts []string, usage string, aliases ...string) (flag *OptionFlag, err error)

Option returns new string flag. Argument "opts" is string slice of options this flag accepts.

func (*OptionFlag) Parse 

func (f *OptionFlag) Parse(args []string) (ok bool, err error)

Parse the OptionFlag.

func (*OptionFlag) Usage added in v0.6.0 

func (f *OptionFlag) Usage() string

Usage returns a usage description for that flag.

func (*OptionFlag) Value 

func (f *OptionFlag) Value() []string

Value returns parsed options.

type UintFlag 

type UintFlag struct {
	Common
	// contains filtered or unexported fields
}

UintFlag defines a uint flag with specified name.

func Uint 

func Uint(name string, value uint, usage string, aliases ...string) (flag *UintFlag, err error)

Uint returns new uint flag. Argument "a" can be any nr of aliases.

func (*UintFlag) Parse 

func (f *UintFlag) Parse(args []string) (bool, error)

Parse uint flag.

func (*UintFlag) Unset 

func (f *UintFlag) Unset()

Unset the int flag value.

func (*UintFlag) Value 

func (f *UintFlag) Value() uint

Value returns uint flag value, it returns default value if not present or 0 if default is also not set.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.