varflag

package
v0.2.4 Latest Latest
Warning

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

 Go to latest Published: Feb 3, 2023 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Overview

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

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

Index

Examples

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")
)

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.

Example 
package main

import (
	"fmt"
	"log"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	os.Args = []string{
		"/bin/app",
		"-v",
		"--str1",
		"some value",
		"arg1",
		"arg2",
		"--str2",
		"some other value",
	}

	str1, err := varflag.New("str1", ".", "some string")
	if err != nil {
		log.Println(err)
		return
	}

	str2, err := varflag.New("str2", "", "some other string")
	if err != nil {
		log.Println(err)
		return
	}

	_ = varflag.Parse([]varflag.Flag{str1, str2}, os.Args)

	fmt.Printf(
		"found %q with value %q, (%t) - it was global flag (%t) in position %d\n",
		str1.Name(),
		str1.Value(),
		str1.Present(),
		str1.Global(),
		str1.Pos(),
	)

	fmt.Printf(
		"found %q with value %q, (%t) - it was global flag (%t) in position %d\n",
		str2.Name(),
		str2.Value(),
		str2.Present(),
		str2.Global(),
		str2.Pos(),
	)
}

Output:

found "str1" with value "some value", (true) - it was global flag (true) in position 3
found "str2" with value "some other value", (true) - it was global flag (true) in position 7

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.

Example 
package main

import (
	"fmt"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	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"}

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.

Example 
package main

import (
	"fmt"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	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

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.

Example 
package main

import (
	"fmt"
	"log"
	"os"

	"github.com/mkungla/happy/pkg/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
	}
	// if you have single flag then parse it directly.
	// no need for pkg .Parse
	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.UsageAliases())
	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.Hidden())
	// 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.Global())
	fmt.Printf("%-12s%q\n", "command", str.BelongsTo())
	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.Required())
}

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

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 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 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 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.

Example 
package main

import (
	"fmt"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	os.Args = []string{
		"/bin/app", "cmd1", "--flag1", "val1", "--flag2", "flag2-value", "arg1", "--flag3=on",
		"-v",                                                          // global flag can be any place
		"subcmd", "--flag4", "val 4 flag", "arg2", "arg3", "-x", "on", // global flag can be any place
	}

	// Global app flags
	global, _ := varflag.NewFlagSet(os.Args[0], 0)

	v, _ := varflag.Bool("verbose", false, "increase verbosity", "v")
	x, _ := varflag.Bool("x", false, "print commands")
	r, _ := varflag.Bool("random", false, "random flag")
	global.Add(v, x, r)

	flag1, _ := varflag.New("flag1", "", "first flag for first cmd")
	flag2, _ := varflag.New("flag2", "", "another flag for first cmd")
	flag3, _ := varflag.Bool("flag3", false, "bool flag for first command")
	cmd1, _ := varflag.NewFlagSet("cmd1", 1)
	cmd1.Add(flag1, flag2, flag3)

	cmd2, _ := varflag.NewFlagSet("cmd2", 0)
	flag5, _ := varflag.New("flag5", "", "flag5 for second cmd")
	cmd2.Add(flag5)

	subcmd, _ := varflag.NewFlagSet("subcmd", 1)
	flag4, _ := varflag.New("flag4", "", "flag4 for sub command")
	subcmd.Add(flag4)
	cmd1.AddSet(subcmd)

	global.AddSet(cmd1, cmd2)
	_ = global.Parse(os.Args)

	// result
	fmt.Printf("%-12s%t (%t) - %s (%s)\n", "verbose", v.Present(), v.Global(), v.String(), v.BelongsTo())
	fmt.Printf("%-12s%t (%t) - %s (%s)\n", "x", x.Present(), x.Global(), x.String(), x.BelongsTo())
	fmt.Printf("%-12s%t (%t) - %s (%s)\n", "random", r.Present(), r.Global(), r.String(), r.BelongsTo())
	fmt.Printf("%-12s %v\n", "gloabal args", global.Args())

	fmt.Printf("\n%-12s%t\n", "cmd1", cmd1.Present())
	fmt.Printf("%-12s%t (%t) - %s\n", "flag1", flag1.Present(), flag1.Global(), flag1.String())
	fmt.Printf("%-12s%t (%t) - %s\n", "flag2", flag2.Present(), flag2.Global(), flag2.String())
	fmt.Printf("%-12s%t (%t) - %s\n", "flag3", flag3.Present(), flag3.Global(), flag3.String())
	fmt.Printf("%-12s %v\n", "cmd1 args", cmd1.Args())

	fmt.Printf("\n%-12s%t\n", "subcmd", subcmd.Present())
	fmt.Printf("%-12s%t (%t) - %s\n", "flag4", flag4.Present(), flag4.Global(), flag4.String())
	fmt.Printf("%-12s %v\n", "subcmd args", subcmd.Args())

	fmt.Printf("\n%-12s%t\n", "cmd2", cmd2.Present())

	// flag3 will not be present since it belongs to cmd 2
	fmt.Printf("%-12s%t (%t)\n", "flag5", flag5.Present(), flag5.Global())

}

Output:

verbose     true (true) - true (/)
x           true (true) - true (/)
random      false (false) - false (/)
gloabal args []

cmd1        true
flag1       true (false) - val1
flag2       true (false) - flag2-value
flag3       true (false) - true
cmd1 args    [arg1]

subcmd      true
flag4       true (false) - val 4 flag
subcmd args  [arg2 arg3]

cmd2        false
flag5       false (false)

func NewFlagSet 

func NewFlagSet(name string, argsn 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.

Example 
package main

import (
	"fmt"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	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

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.

Example 
package main

import (
	"fmt"
	"math"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	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

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.

Example 
package main

import (
	"fmt"
	"os"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	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"}

func (*OptionFlag) Parse 

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

Parse the OptionFlag.

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.

Example 
package main

import (
	"fmt"
	"math"
	"os"
	"strconv"

	"github.com/mkungla/happy/pkg/varflag"
)

func main() {
	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

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.