cli

packagemodule

v3.3.8Latest Latest

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

Go to latest Published: Jun 12, 2025 License:MITImports:25Imported by:1,156

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/urfave/cli

README ¶

Welcome to urfave/cli

urfave/cli is adeclarative, simple, fast, and fun package for buildingcommand line tools in Go featuring:

commands and subcommands with alias and prefix match support
flexible and permissive help system
dynamic shell completion forbash,zsh,fish, andpowershell
no dependencies except Go standard library
input flags for simple types, slices of simple types, time, duration, andothers
compound short flag support (-a-b-c can be shortened to-abc)
documentation generation inman and Markdown (supported via theurfave/cli-docs module)
input lookup from:
- environment variables
- plain text files
- structured file formats (supported via theurfave/cli-altsrc module)

Documentation

See the hosted documentation website athttps://cli.urfave.org. Contents ofthis website are built from the./docs directory.

Support

Check theQ&A discussions. If you don't find answer to your question,createa new discussion.

If you found a bug or have a feature request,create a new issue.

Please keep in mind that this project is run by unpaid volunteers.

License

SeeLICENSE.

Documentation¶

Overview¶

Package cli provides a minimal framework for creating and organizing command lineGo applications. cli is designed to be easy to understand and write, the most simplecli application can be written as follows:

func main() {(&cli.Command{}).Run(context.Background(), os.Args)}

Of course this application does not do much, so let's make this an actual application:

func main() {cmd := &cli.Command{  Name: "greet",  Usage: "say a greeting",  Action: func(c *cli.Context) error {  fmt.Println("Greetings")  return nil  },}cmd.Run(context.Background(), os.Args)}

Index¶

Examples¶

Constants¶

This section is empty.

Variables¶

View Source

var (NewFloatSlice   =NewSliceBase[float64,NoConfig, floatValue[float64]]NewFloat32Slice =NewSliceBase[float32,NoConfig, floatValue[float32]]NewFloat64Slice =NewSliceBase[float64,NoConfig, floatValue[float64]])

View Source

var (NewIntSlice   =NewSliceBase[int,IntegerConfig, intValue[int]]NewInt8Slice  =NewSliceBase[int8,IntegerConfig, intValue[int8]]NewInt16Slice =NewSliceBase[int16,IntegerConfig, intValue[int16]]NewInt32Slice =NewSliceBase[int32,IntegerConfig, intValue[int32]]NewInt64Slice =NewSliceBase[int64,IntegerConfig, intValue[int64]])

View Source

var (NewUintSlice   =NewSliceBase[uint,IntegerConfig, uintValue[uint]]NewUint8Slice  =NewSliceBase[uint8,IntegerConfig, uintValue[uint8]]NewUint16Slice =NewSliceBase[uint16,IntegerConfig, uintValue[uint16]]NewUint32Slice =NewSliceBase[uint32,IntegerConfig, uintValue[uint32]]NewUint64Slice =NewSliceBase[uint64,IntegerConfig, uintValue[uint64]])

View Source

var (SuggestFlagSuggestFlagFunc    = suggestFlagSuggestCommandSuggestCommandFunc = suggestCommandSuggestDidYouMeanTemplatestring             = suggestDidYouMeanTemplate)

View Source

var AnyArguments = []Argument{&StringArgs{Max: -1,},}

AnyArguments to differentiate between no arguments(nil) vs aleast one

View Source

var CommandHelpTemplate = ``/* 477-byte string literal not displayed */

CommandHelpTemplate is the text template for the command help topic.cli.go uses text/template to render templates. You canrender custom help text by setting this variable.

View Source

var DefaultInverseBoolPrefix = "no-"

View Source

var ErrWriterio.Writer =os.Stderr

ErrWriter is used to write errors to the user. This can be anythingimplementing the io.Writer interface and defaults to os.Stderr.

View Source

var FishCompletionTemplate = ``/* 366-byte string literal not displayed */

View Source

var HelpPrinter helpPrinter = printHelp

HelpPrinter is a function that writes the help output. If not set explicitly,this calls HelpPrinterCustom using only the default template functions.

If custom logic for printing help is required, this function can beoverridden. If the ExtraInfo field is defined on an App, this functionshould not be modified, as HelpPrinterCustom will be used directly in orderto capture the extra information.

View Source

var HelpPrinterCustom helpPrinterCustom = printHelpCustom

HelpPrinterCustom is a function that writes the help output. It is used asthe default implementation of HelpPrinter, and may be called directly ifthe ExtraInfo field is set on an App.

In the default implementation, if the customFuncs argument contains a"wrapAt" key, which is a function which takes no arguments and returnsan int, this int value will be used to produce a "wrap" function usedby the default template to wrap long lines.

View Source

var NewStringMap =NewMapBase[string,StringConfig, stringValue]

View Source

var NewStringSlice =NewSliceBase[string,StringConfig, stringValue]

View Source

var OsExiter =os.Exit

OsExiter is the function used when the app exits. If not set defaults to os.Exit.

View Source

var RootCommandHelpTemplate = ``/* 873-byte string literal not displayed */

RootCommandHelpTemplate is the text template for the Default help topic.cli.go uses text/template to render templates. You canrender custom help text by setting this variable.

View Source

var SubcommandHelpTemplate = ``/* 637-byte string literal not displayed */

SubcommandHelpTemplate is the text template for the subcommand help topic.cli.go uses text/template to render templates. You canrender custom help text by setting this variable.

View Source

var VersionPrinter = printVersion

VersionPrinter prints the version for the App

Functions¶

funcDefaultAppComplete ¶

func DefaultAppComplete(ctxcontext.Context, cmd *Command)

DefaultAppComplete prints the list of subcommands as the default app completion method

funcDefaultCompleteWithFlags ¶

func DefaultCompleteWithFlags(ctxcontext.Context, cmd *Command)

funcFlagNames ¶

func FlagNames(namestring, aliases []string) []string

funcHandleExitCoder ¶

func HandleExitCoder(errerror)

HandleExitCoder handles errors implementing ExitCoder by printing theirmessage and calling OsExiter with the given exit code.

If the given error instead implements MultiError, each error will be checkedfor the ExitCoder interface, and OsExiter will be called with the last exitcode found, or exit code 1 if no ExitCoder is found.

This function is the default error-handling behavior for an App.

funcShowAppHelp ¶

func ShowAppHelp(cmd *Command)error

ShowAppHelp is an action that displays the help.

funcShowAppHelpAndExit ¶

func ShowAppHelpAndExit(cmd *Command, exitCodeint)

ShowAppHelpAndExit - Prints the list of subcommands for the app and exits with exit code.

funcShowCommandHelp ¶

func ShowCommandHelp(ctxcontext.Context, cmd *Command, commandNamestring)error

ShowCommandHelp prints help for the given command

funcShowCommandHelpAndExit ¶

func ShowCommandHelpAndExit(ctxcontext.Context, cmd *Command, commandstring, codeint)

ShowCommandHelpAndExit - exits with code after showing help

funcShowSubcommandHelp ¶

func ShowSubcommandHelp(cmd *Command)error

ShowSubcommandHelp prints help for the given subcommand

funcShowSubcommandHelpAndExit ¶

func ShowSubcommandHelpAndExit(cmd *Command, exitCodeint)

ShowSubcommandHelpAndExit - Prints help for the given subcommand and exits with exit code.

funcShowVersion ¶

func ShowVersion(cmd *Command)

ShowVersion prints the version number of the App

Types¶

typeActionFunc ¶

type ActionFunc func(context.Context, *Command)error

ActionFunc is the action to execute when no subcommands are specified

typeActionableFlag ¶

type ActionableFlag interface {RunAction(context.Context, *Command)error}

ActionableFlag is an interface that wraps Flag interface and RunAction operation.

typeAfterFunc ¶

type AfterFunc func(context.Context, *Command)error

AfterFunc is an action that executes after any subcommands are run and havefinished. The AfterFunc is run even if Action() panics.

typeArgs ¶

type Args interface {// Get returns the nth argument, or else a blank stringGet(nint)string// First returns the first argument, or else a blank stringFirst()string// Tail returns the rest of the arguments (not the first one)// or else an empty string sliceTail() []string// Len returns the length of the wrapped sliceLen()int// Present checks if there are any arguments presentPresent()bool// Slice returns a copy of the internal sliceSlice() []string}

typeArgument ¶

type Argument interface {// which this argument can be accessed using the given nameHasName(string)bool// Parse the given args and return unparsed args and/or errorParse([]string) ([]string,error)// The usage template for this argument to use in helpUsage()string// The Value of this ArgGet()any}

Argument captures a positional argument that canbe parsed

typeArgumentBase ¶

type ArgumentBase[Tany, Cany, VCValueCreator[T, C]] struct {Namestring `json:"name"`// the name of this argumentValue       T      `json:"value"`// the default value of this argumentDestination *T     `json:"-"`// the destination point for this argumentUsageTextstring `json:"usageText"`// the usage text to showConfig      C      `json:"config"`// config for this argument similar to Flag Config// contains filtered or unexported fields}

func (*ArgumentBase[T, C, VC])Get ¶added inv3.2.0

func (a *ArgumentBase[T, C, VC]) Get()any

func (*ArgumentBase[T, C, VC])HasName ¶added inv3.2.0

func (a *ArgumentBase[T, C, VC]) HasName(sstring)bool

func (*ArgumentBase[T, C, VC])Parse ¶

func (a *ArgumentBase[T, C, VC]) Parse(s []string) ([]string,error)

func (*ArgumentBase[T, C, VC])Usage ¶

func (a *ArgumentBase[T, C, VC]) Usage()string

typeArgumentsBase ¶added inv3.2.0

type ArgumentsBase[Tany, Cany, VCValueCreator[T, C]] struct {Namestring `json:"name"`// the name of this argumentValue       T      `json:"value"`// the default value of this argumentDestination *[]T   `json:"-"`// the destination point for this argumentUsageTextstring `json:"usageText"`// the usage text to showMinint    `json:"minTimes"`// the min num of occurrences of this argumentMaxint    `json:"maxTimes"`// the max num of occurrences of this argument, set to -1 for unlimitedConfig      C      `json:"config"`// config for this argument similar to Flag Config// contains filtered or unexported fields}

ArgumentsBase is a base type for slice arguments

func (*ArgumentsBase[T, C, VC])Get ¶added inv3.2.0

func (a *ArgumentsBase[T, C, VC]) Get()any

func (*ArgumentsBase[T, C, VC])HasName ¶added inv3.2.0

func (a *ArgumentsBase[T, C, VC]) HasName(sstring)bool

func (*ArgumentsBase[T, C, VC])Parse ¶added inv3.2.0

func (a *ArgumentsBase[T, C, VC]) Parse(s []string) ([]string,error)

func (*ArgumentsBase[T, C, VC])Usage ¶added inv3.2.0

func (a *ArgumentsBase[T, C, VC]) Usage()string

typeBeforeFunc ¶

type BeforeFunc func(context.Context, *Command) (context.Context,error)

BeforeFunc is an action that executes prior to any subcommands being run oncethe context is ready. If a non-nil error is returned, no subcommands arerun.

typeBoolConfig ¶

type BoolConfig struct {Count *int}

BoolConfig defines the configuration for bool flags

typeBoolFlag ¶

type BoolFlag =FlagBase[bool,BoolConfig, boolValue]

typeBoolWithInverseFlag ¶

type BoolWithInverseFlag struct {Namestring                                      `json:"name"`// name of the flagCategorystring                                      `json:"category"`// category of the flag, if anyDefaultTextstring                                      `json:"defaultText"`// default text of the flag for usage purposesHideDefaultbool                                        `json:"hideDefault"`// whether to hide the default value in outputUsagestring                                      `json:"usage"`// usage string for help outputSourcesValueSourceChain                            `json:"-"`// sources to load flag value fromRequiredbool                                        `json:"required"`// whether the flag is required or notHiddenbool                                        `json:"hidden"`// whether to hide the flag in help outputLocalbool                                        `json:"local"`// whether the flag needs to be applied to subcommands as wellValuebool                                        `json:"defaultValue"`// default value for this flag if not set by from any sourceDestination      *bool                                       `json:"-"`// destination pointer for value when setAliases          []string                                    `json:"aliases"`// Aliases that are allowed for this flagTakesFilebool                                        `json:"takesFileArg"`// whether this flag takes a file argument, mainly for shell completion purposesAction           func(context.Context, *Command,bool)error `json:"-"`// Action callback to be called when flag is setOnlyOncebool                                        `json:"onlyOnce"`// whether this flag can be duplicated on the command lineValidator        func(bool)error                            `json:"-"`// custom function to validate this flag valueValidateDefaultsbool                                        `json:"validateDefaults"`// whether to validate defaults or notConfigBoolConfig                                  `json:"config"`// Additional/Custom configuration associated with this flag typeInversePrefixstring                                      `json:"invPrefix"`// The prefix used to indicate a negative value. Default: `env` becomes `no-env`// contains filtered or unexported fields}

Example¶

package mainimport ("context""fmt"cli "github.com/urfave/cli/v3")func main() {flagWithInverse := &cli.BoolWithInverseFlag{Name: "env",}cmd := &cli.Command{Flags: []cli.Flag{flagWithInverse,},Action: func(_ context.Context, cmd *cli.Command) error {if flagWithInverse.IsSet() {if cmd.Bool("env") {fmt.Println("env is set")} else {fmt.Println("no-env is set")}}return nil},}_ = cmd.Run(context.Background(), []string{"prog", "--no-env"})fmt.Println("flags:", len(flagWithInverse.Names()))}

Output:no-env is setflags: 2

func (*BoolWithInverseFlag)Count ¶

func (bif *BoolWithInverseFlag) Count()int

Count returns the number of times this flag has been invoked

func (*BoolWithInverseFlag)Get ¶

func (bif *BoolWithInverseFlag) Get()any

func (*BoolWithInverseFlag)GetCategory ¶

func (bif *BoolWithInverseFlag) GetCategory()string

GetCategory returns the category of the flag

func (*BoolWithInverseFlag)GetDefaultText ¶

func (bif *BoolWithInverseFlag) GetDefaultText()string

GetDefaultText returns the default text for this flag

func (*BoolWithInverseFlag)GetEnvVars ¶

func (bif *BoolWithInverseFlag) GetEnvVars() []string

GetEnvVars returns the env vars for this flag

func (*BoolWithInverseFlag)GetUsage ¶

func (bif *BoolWithInverseFlag) GetUsage()string

GetUsage returns the usage string for the flag

func (*BoolWithInverseFlag)GetValue ¶

func (bif *BoolWithInverseFlag) GetValue()string

GetValue returns the flags value as string representation and an emptystring if the flag takes no value at all.

func (*BoolWithInverseFlag)IsBoolFlag ¶

func (bif *BoolWithInverseFlag) IsBoolFlag()bool

IsBoolFlag returns whether the flag doesnt need to accept args

func (*BoolWithInverseFlag)IsDefaultVisible ¶

func (bif *BoolWithInverseFlag) IsDefaultVisible()bool

IsDefaultVisible returns true if the flag is not hidden, otherwise false

func (*BoolWithInverseFlag)IsLocal ¶added inv3.3.7

func (bif *BoolWithInverseFlag) IsLocal()bool

func (*BoolWithInverseFlag)IsRequired ¶added inv3.3.5

func (bif *BoolWithInverseFlag) IsRequired()bool

func (*BoolWithInverseFlag)IsSet ¶

func (bif *BoolWithInverseFlag) IsSet()bool

func (*BoolWithInverseFlag)IsVisible ¶added inv3.3.5

func (bif *BoolWithInverseFlag) IsVisible()bool

func (*BoolWithInverseFlag)Names ¶

func (bif *BoolWithInverseFlag) Names() []string

func (*BoolWithInverseFlag)PostParse ¶

func (bif *BoolWithInverseFlag) PostParse()error

func (*BoolWithInverseFlag)PreParse ¶

func (bif *BoolWithInverseFlag) PreParse()error

func (*BoolWithInverseFlag)RunAction ¶

func (bif *BoolWithInverseFlag) RunAction(ctxcontext.Context, cmd *Command)error

func (*BoolWithInverseFlag)Set ¶

func (bif *BoolWithInverseFlag) Set(name, valstring)error

func (*BoolWithInverseFlag)SetCategory ¶

func (bif *BoolWithInverseFlag) SetCategory(cstring)

func (*BoolWithInverseFlag)String ¶

func (bif *BoolWithInverseFlag) String()string

String implements the standard Stringer interface.

Example for BoolFlag{Name: "env"}--[no-]env(default: false)

func (*BoolWithInverseFlag)TakesValue ¶

func (bif *BoolWithInverseFlag) TakesValue()bool

func (*BoolWithInverseFlag)TypeName ¶

func (bif *BoolWithInverseFlag) TypeName()string

TypeName is used for stringify/docs. For bool its a no-op

typeCategorizableFlag ¶

type CategorizableFlag interface {// Returns the category of the flagGetCategory()string// Sets the category of the flagSetCategory(string)}

CategorizableFlag is an interface that allows us to potentiallyuse a flag in a categorized representation.

typeCommand ¶

type Command struct {// The name of the commandNamestring `json:"name"`// A list of aliases for the commandAliases []string `json:"aliases"`// A short description of the usage of this commandUsagestring `json:"usage"`// Text to override the USAGE section of helpUsageTextstring `json:"usageText"`// A short description of the arguments of this commandArgsUsagestring `json:"argsUsage"`// Version of the commandVersionstring `json:"version"`// Longer explanation of how the command worksDescriptionstring `json:"description"`// DefaultCommand is the (optional) name of a command// to run if no command names are passed as CLI arguments.DefaultCommandstring `json:"defaultCommand"`// The category the command is part ofCategorystring `json:"category"`// List of child commandsCommands []*Command `json:"commands"`// List of flags to parseFlags []Flag `json:"flags"`// Boolean to hide built-in help command and help flagHideHelpbool `json:"hideHelp"`// Ignored if HideHelp is true.HideHelpCommandbool `json:"hideHelpCommand"`// Boolean to hide built-in version flag and the VERSION section of helpHideVersionbool `json:"hideVersion"`// Boolean to enable shell completion commandsEnableShellCompletionbool `json:"-"`// Shell Completion generation command nameShellCompletionCommandNamestring `json:"-"`// The function to call when checking for shell command completionsShellCompleteShellCompleteFunc `json:"-"`// The function to configure a shell completion commandConfigureShellCompletionCommandConfigureShellCompletionCommand `json:"-"`// An action to execute before any subcommands are run, but after the context is ready// If a non-nil error is returned, no subcommands are runBeforeBeforeFunc `json:"-"`// An action to execute after any subcommands are run, but after the subcommand has finished// It is run even if Action() panicsAfterAfterFunc `json:"-"`// The function to call when this command is invokedActionActionFunc `json:"-"`// Execute this function if the proper command cannot be foundCommandNotFoundCommandNotFoundFunc `json:"-"`// Execute this function if a usage error occurs.OnUsageErrorOnUsageErrorFunc `json:"-"`// Execute this function when an invalid flag is accessed from the contextInvalidFlagAccessHandlerInvalidFlagAccessFunc `json:"-"`// Boolean to hide this command from help or completionHiddenbool `json:"hidden"`// List of all authors who contributed (string or fmt.Stringer)// TODO: ~string | fmt.Stringer when interface unions are availableAuthors []any `json:"authors"`// Copyright of the binary if anyCopyrightstring `json:"copyright"`// Reader reader to write input to (useful for tests)Readerio.Reader `json:"-"`// Writer writer to write output toWriterio.Writer `json:"-"`// ErrWriter writes error outputErrWriterio.Writer `json:"-"`// ExitErrHandler processes any error encountered while running an App before// it is returned to the caller. If no function is provided, HandleExitCoder// is used as the default behavior.ExitErrHandlerExitErrHandlerFunc `json:"-"`// Other custom infoMetadata map[string]interface{} `json:"metadata"`// Carries a function which returns app specific info.ExtraInfo func() map[string]string `json:"-"`// CustomRootCommandHelpTemplate the text template for app help topic.// cli.go uses text/template to render templates. You can// render custom help text by setting this variable.CustomRootCommandHelpTemplatestring `json:"-"`// SliceFlagSeparator is used to customize the separator for SliceFlag, the default is ","SliceFlagSeparatorstring `json:"sliceFlagSeparator"`// DisableSliceFlagSeparator is used to disable SliceFlagSeparator, the default is falseDisableSliceFlagSeparatorbool `json:"disableSliceFlagSeparator"`// Boolean to enable short-option handling so user can combine several// single-character bool arguments into one// i.e. foobar -o -v -> foobar -ovUseShortOptionHandlingbool `json:"useShortOptionHandling"`// Enable suggestions for commands and flagsSuggestbool `json:"suggest"`// Allows global flags set by libraries which use flag.XXXVar(...) directly// to be parsed through this libraryAllowExtFlagsbool `json:"allowExtFlags"`// Treat all flags as normal arguments if trueSkipFlagParsingbool `json:"skipFlagParsing"`// CustomHelpTemplate the text template for the command help topic.// cli.go uses text/template to render templates. You can// render custom help text by setting this variable.CustomHelpTemplatestring `json:"-"`// Use longest prefix match for commandsPrefixMatchCommandsbool `json:"prefixMatchCommands"`// Custom suggest command for matchingSuggestCommandFuncSuggestCommandFunc `json:"-"`// Flag exclusion groupMutuallyExclusiveFlags []MutuallyExclusiveFlags `json:"mutuallyExclusiveFlags"`// Arguments to parse for this commandArguments []Argument `json:"arguments"`// Whether to read arguments from stdin// applicable to root command onlyReadArgsFromStdinbool `json:"readArgsFromStdin"`// contains filtered or unexported fields}

Command contains everything needed to run an application thataccepts a string slice of arguments such as os.Args. A givenCommand may contain Flags and sub-commands in Commands.

func (*Command)Args ¶

func (cmd *Command) Args()Args

Args returns the command line arguments associated with thecommand.

func (*Command)Bool ¶

func (cmd *Command) Bool(namestring)bool

func (*Command)Command ¶

func (cmd *Command) Command(namestring) *Command

func (*Command)Count ¶

func (cmd *Command) Count(namestring)int

Count returns the num of occurrences of this flag

func (*Command)Duration ¶

func (cmd *Command) Duration(namestring)time.Duration

func (*Command)FlagNames ¶

func (cmd *Command) FlagNames() []string

FlagNames returns a slice of flag names used by the this commandand all of its parent commands.

func (*Command)Float ¶

func (cmd *Command) Float(namestring)float64

Float looks up the value of a local FloatFlag, returns0 if not found

func (*Command)Float32 ¶added inv3.3.0

func (cmd *Command) Float32(namestring)float32

Float32 looks up the value of a local Float32Flag, returns0 if not found

func (*Command)Float32Arg ¶added inv3.3.0

func (c *Command) Float32Arg(namestring)float32

func (*Command)Float32Args ¶added inv3.3.0

func (c *Command) Float32Args(namestring) []float32

func (*Command)Float32Slice ¶added inv3.3.0

func (cmd *Command) Float32Slice(namestring) []float32

Float32Slice looks up the value of a local Float32Slice, returnsnil if not found

func (*Command)Float64 ¶added inv3.3.0

func (cmd *Command) Float64(namestring)float64

Float64 looks up the value of a local Float64Flag, returns0 if not found

func (*Command)Float64Arg ¶added inv3.3.0

func (c *Command) Float64Arg(namestring)float64

func (*Command)Float64Args ¶added inv3.3.0

func (c *Command) Float64Args(namestring) []float64

func (*Command)Float64Slice ¶added inv3.3.0

func (cmd *Command) Float64Slice(namestring) []float64

Float64Slice looks up the value of a local Float64SliceFlag, returnsnil if not found

func (*Command)FloatArg ¶added inv3.2.0

func (c *Command) FloatArg(namestring)float64

func (*Command)FloatArgs ¶added inv3.2.0

func (c *Command) FloatArgs(namestring) []float64

func (*Command)FloatSlice ¶

func (cmd *Command) FloatSlice(namestring) []float64

FloatSlice looks up the value of a local FloatSliceFlag, returnsnil if not found

func (*Command)FullName ¶

func (cmd *Command) FullName()string

FullName returns the full name of the command.For commands with parents this ensures that the parent commandsare part of the command path.

func (*Command)Generic ¶

func (cmd *Command) Generic(namestring)Value

Generic looks up the value of a local GenericFlag, returnsnil if not found

func (*Command)HasName ¶

func (cmd *Command) HasName(namestring)bool

HasName returns true if Command.Name matches given name

func (*Command)Int ¶

func (cmd *Command) Int(namestring)int

Int looks up the value of a local Int64Flag, returns0 if not found

func (*Command)Int16 ¶added inv3.2.0

func (cmd *Command) Int16(namestring)int16

Int16 looks up the value of a local Int16Flag, returns0 if not found

func (*Command)Int16Arg ¶added inv3.2.0

func (c *Command) Int16Arg(namestring)int16

func (*Command)Int16Args ¶added inv3.2.0

func (c *Command) Int16Args(namestring) []int16

func (*Command)Int16Slice ¶added inv3.2.0

func (cmd *Command) Int16Slice(namestring) []int16

Int16Slice looks up the value of a local Int16SliceFlag, returnsnil if not found

func (*Command)Int32 ¶added inv3.2.0

func (cmd *Command) Int32(namestring)int32

Int32 looks up the value of a local Int32Flag, returns0 if not found

func (*Command)Int32Arg ¶added inv3.2.0

func (c *Command) Int32Arg(namestring)int32

func (*Command)Int32Args ¶added inv3.2.0

func (c *Command) Int32Args(namestring) []int32

func (*Command)Int32Slice ¶added inv3.2.0

func (cmd *Command) Int32Slice(namestring) []int32

Int32Slice looks up the value of a local Int32SliceFlag, returnsnil if not found

func (*Command)Int64 ¶added inv3.2.0

func (cmd *Command) Int64(namestring)int64

Int64 looks up the value of a local Int64Flag, returns0 if not found

func (*Command)Int64Arg ¶added inv3.2.0

func (c *Command) Int64Arg(namestring)int64

func (*Command)Int64Args ¶added inv3.2.0

func (c *Command) Int64Args(namestring) []int64

func (*Command)Int64Slice ¶added inv3.2.0

func (cmd *Command) Int64Slice(namestring) []int64

Int64Slice looks up the value of a local Int64SliceFlag, returnsnil if not found

func (*Command)Int8 ¶added inv3.2.0

func (cmd *Command) Int8(namestring)int8

Int8 looks up the value of a local Int8Flag, returns0 if not found

func (*Command)Int8Arg ¶added inv3.2.0

func (c *Command) Int8Arg(namestring)int8

func (*Command)Int8Args ¶added inv3.2.0

func (c *Command) Int8Args(namestring) []int8

func (*Command)Int8Slice ¶added inv3.2.0

func (cmd *Command) Int8Slice(namestring) []int8

Int8Slice looks up the value of a local Int8SliceFlag, returnsnil if not found

func (*Command)IntArg ¶added inv3.2.0

func (c *Command) IntArg(namestring)int

func (*Command)IntArgs ¶added inv3.2.0

func (c *Command) IntArgs(namestring) []int

func (*Command)IntSlice ¶

func (cmd *Command) IntSlice(namestring) []int

IntSlice looks up the value of a local IntSliceFlag, returnsnil if not found

func (*Command)IsSet ¶

func (cmd *Command) IsSet(namestring)bool

IsSet determines if the flag was actually set

func (*Command)Lineage ¶

func (cmd *Command) Lineage() []*Command

Lineage returns *this* command and all of its ancestor commandsin order from child to parent

func (*Command)LocalFlagNames ¶

func (cmd *Command) LocalFlagNames() []string

LocalFlagNames returns a slice of flag names used in thiscommand.

func (*Command)NArg ¶

func (cmd *Command) NArg()int

NArg returns the number of the command line arguments.

func (*Command)Names ¶

func (cmd *Command) Names() []string

Names returns the names including short names and aliases.

func (*Command)NumFlags ¶

func (cmd *Command) NumFlags()int

NumFlags returns the number of flags set

func (*Command)Root ¶

func (cmd *Command) Root() *Command

Root returns the Command at the root of the graph

func (*Command)Run ¶

func (cmd *Command) Run(ctxcontext.Context, osArgs []string) (deferErrerror)

Run is the entry point to the command graph. The positionalarguments are parsed according to the Flag and Commanddefinitions and the matching Action functions are run.

Example¶

package mainimport ("context""fmt""net/mail""os"cli "github.com/urfave/cli/v3")func main() {// Declare a commandcmd := &cli.Command{Name: "greet",Flags: []cli.Flag{&cli.StringFlag{Name: "name", Value: "pat", Usage: "a name to say"},},Action: func(_ context.Context, cmd *cli.Command) error {fmt.Printf("Hello %[1]v\n", cmd.String("name"))return nil},Authors: []any{&mail.Address{Name: "Oliver Allen", Address: "oliver@toyshop.example.com"},"gruffalo@soup-world.example.org",},Version: "v0.13.12",}// Simulate the command line argumentsos.Args = []string{"greet", "--name", "Jeremy"}if err := cmd.Run(context.Background(), os.Args); err != nil {// do something with unhandled errorsfmt.Fprintf(os.Stderr, "Unhandled error: %[1]v\n", err)os.Exit(86)}}

Output:Hello Jeremy

Example (AppHelp)¶

package mainimport ("context""fmt""net/mail""os""time"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:        "greet",Version:     "0.1.0",Description: "This is how we describe greet the app",Authors: []any{&mail.Address{Name: "Harrison", Address: "harrison@lolwut.example.com"},"Oliver Allen  <oliver@toyshop.example.com>",},Flags: []cli.Flag{&cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},},Arguments: cli.AnyArguments,Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",ArgsUsage:   "[arguments...]",Action: func(context.Context, *cli.Command) error {fmt.Printf("i like to describe things")return nil},},},}ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)defer cancel()// Simulate the command line argumentsos.Args = []string{"greet", "help"}_ = cmd.Run(ctx, os.Args)}

Output:NAME:   greet - A new cli applicationUSAGE:   greet [global options] [command [command options]] [arguments...]VERSION:   0.1.0DESCRIPTION:   This is how we describe greet the appAUTHORS:   "Harrison" <harrison@lolwut.example.com>   Oliver Allen  <oliver@toyshop.example.com>COMMANDS:   describeit, d  use it to see a description   help, h        Shows a list of commands or help for one commandGLOBAL OPTIONS:   --name string  a name to say (default: "bob")   --help, -h     show help   --version, -v  print the version

Example (CommandHelp)¶

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "greet",Flags: []cli.Flag{&cli.StringFlag{Name: "name", Value: "pat", Usage: "a name to say"},},Action: func(_ context.Context, cmd *cli.Command) error {fmt.Fprintf(cmd.Root().Writer, "hello to %[1]q\n", cmd.String("name"))return nil},Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",ArgsUsage:   "[arguments...]",Action: func(context.Context, *cli.Command) error {fmt.Println("i like to describe things")return nil},},},}// Simulate the command line argumentsos.Args = []string{"greet", "h", "describeit"}_ = cmd.Run(context.Background(), os.Args)}

Output:NAME:   greet describeit - use it to see a descriptionUSAGE:   greet describeit [arguments...]DESCRIPTION:   This is how we describe describeit the functionOPTIONS:   --help, -h  show help

Example (MapValues)¶

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "multi_values",Flags: []cli.Flag{&cli.StringMapFlag{Name: "stringMap"},},HideHelp: true,Action: func(ctx context.Context, cmd *cli.Command) error {for i, v := range cmd.FlagNames() {fmt.Printf("%d-%s %#v\n", i, v, cmd.StringMap(v))}fmt.Printf("notfound %#v\n", cmd.StringMap("notfound"))err := ctx.Err()fmt.Println("error:", err)return err},}// Simulate command line argumentsos.Args = []string{"multi_values","--stringMap", "parsed1=parsed two", "--stringMap", "parsed3=",}_ = cmd.Run(context.Background(), os.Args)}

Output:0-stringMap map[string]string{"parsed1":"parsed two", "parsed3":""}notfound map[string]string(nil)error: <nil>

Example (NoAction)¶

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "greet"}// Simulate the command line argumentsos.Args = []string{"greet"}_ = cmd.Run(context.Background(), os.Args)}

Output:NAME:   greet - A new cli applicationUSAGE:   greet [global options]GLOBAL OPTIONS:   --help, -h  show help

Example (ShellComplete_bash)¶

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",Action: func(context.Context, *cli.Command) error {fmt.Printf("i like to describe things")return nil},}, {Name:        "next",Usage:       "next example",Description: "more stuff to see when generating shell completion",Action: func(context.Context, *cli.Command) error {fmt.Printf("the next example")return nil},},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:describeitnexthelp

Example (ShellComplete_bash_withLongFlag)¶

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Flags: []cli.Flag{&cli.Int64Flag{Name:    "other",Aliases: []string{"o"},},&cli.StringFlag{Name:    "xyz",Aliases: []string{"x"},},&cli.StringFlag{Name: "some-flag,s",},&cli.StringFlag{Name: "similar-flag",},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "--s", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:--some-flag--similar-flag

Example (ShellComplete_bash_withMultipleLongFlag)¶

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Flags: []cli.Flag{&cli.Int64Flag{Name:    "int-flag",Aliases: []string{"i"},},&cli.StringFlag{Name:    "string",Aliases: []string{"s"},},&cli.StringFlag{Name: "string-flag-2",},&cli.StringFlag{Name: "similar-flag",},&cli.StringFlag{Name: "some-flag",},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "--st", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:--string--string-flag-2

Example (ShellComplete_bash_withShortFlag)¶

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Flags: []cli.Flag{&cli.Int64Flag{Name:    "other",Aliases: []string{"o"},},&cli.StringFlag{Name:    "xyz",Aliases: []string{"x"},},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "-", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:--other--xyz--help

Example (ShellComplete_zsh)¶

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",Action: func(context.Context, *cli.Command) error {fmt.Printf("i like to describe things")return nil},}, {Name:        "next",Usage:       "next example",Description: "more stuff to see when generating bash completion",Action: func(context.Context, *cli.Command) error {fmt.Printf("the next example")return nil},},},}// Simulate a zsh environment and command line argumentsos.Args = []string{"greet", "--generate-shell-completion"}os.Setenv("SHELL", "/usr/bin/zsh")_ = cmd.Run(context.Background(), os.Args)}

Output:describeit:use it to see a descriptionnext:next examplehelp:Shows a list of commands or help for one command

Example (SliceValues)¶

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "multi_values",Flags: []cli.Flag{&cli.StringSliceFlag{Name: "stringSlice"},&cli.FloatSliceFlag{Name: "float64Slice"},&cli.Int64SliceFlag{Name: "intSlice"},},HideHelp: true,Action: func(ctx context.Context, cmd *cli.Command) error {for i, v := range cmd.FlagNames() {fmt.Printf("%d-%s %#v\n", i, v, cmd.Value(v))}err := ctx.Err()fmt.Println("error:", err)return err},}// Simulate command line argumentsos.Args = []string{"multi_values","--stringSlice", "parsed1,parsed2", "--stringSlice", "parsed3,parsed4","--float64Slice", "13.3,14.4", "--float64Slice", "15.5,16.6","--intSlice", "13,14", "--intSlice", "15,16",}_ = cmd.Run(context.Background(), os.Args)}

Output:0-stringSlice []string{"parsed1", "parsed2", "parsed3", "parsed4"}1-float64Slice []float64{13.3, 14.4, 15.5, 16.6}2-intSlice []int64{13, 14, 15, 16}error: <nil>

Example (Subcommand)¶

package mainimport ("context""fmt""os""time"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "say",Commands: []*cli.Command{{Name:        "hello",Aliases:     []string{"hi"},Usage:       "use it to see a description",Description: "This is how we describe hello the function",Commands: []*cli.Command{{Name:        "english",Aliases:     []string{"en"},Usage:       "sends a greeting in english",Description: "greets someone in english",Flags: []cli.Flag{&cli.StringFlag{Name:  "name",Value: "Bob",Usage: "Name of the person to greet",},},Action: func(_ context.Context, cmd *cli.Command) error {fmt.Println("Hello,", cmd.String("name"))return nil},},},},},}ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)defer cancel()// Simulate the command line argumentsos.Args = []string{"say", "hi", "english", "--name", "Jeremy"}_ = cmd.Run(ctx, os.Args)}

Output:Hello, Jeremy

Example (SubcommandNoAction)¶

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "greet",Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",ArgsUsage:   "[arguments...]",Description: "This is how we describe describeit the function",},},}// Simulate the command line argumentsos.Args = []string{"greet", "describeit"}_ = cmd.Run(context.Background(), os.Args)}

Output:NAME:   greet describeit - use it to see a descriptionUSAGE:   greet describeit [options] [arguments...]DESCRIPTION:   This is how we describe describeit the functionOPTIONS:   --help, -h  show help

func (*Command)Set ¶

func (cmd *Command) Set(name, valuestring)error

Set sets a context flag to a value.

func (*Command)String ¶

func (cmd *Command) String(namestring)string

func (*Command)StringArg ¶added inv3.2.0

func (c *Command) StringArg(namestring)string

func (*Command)StringArgs ¶added inv3.2.0

func (c *Command) StringArgs(namestring) []string

func (*Command)StringMap ¶

func (cmd *Command) StringMap(namestring) map[string]string

StringMap looks up the value of a local StringMapFlag, returnsnil if not found

func (*Command)StringSlice ¶

func (cmd *Command) StringSlice(namestring) []string

StringSlice looks up the value of a local StringSliceFlag, returnsnil if not found

func (*Command)Timestamp ¶

func (cmd *Command) Timestamp(namestring)time.Time

Timestamp gets the timestamp from a flag name

func (*Command)TimestampArg ¶added inv3.2.0

func (c *Command) TimestampArg(namestring)time.Time

func (*Command)TimestampArgs ¶added inv3.2.0

func (c *Command) TimestampArgs(namestring) []time.Time

func (*Command)ToFishCompletion ¶

func (cmd *Command) ToFishCompletion() (string,error)

ToFishCompletion creates a fish completion string for the `*App`The function errors if either parsing or writing of the string fails.

func (*Command)Uint ¶

func (cmd *Command) Uint(namestring)uint

Uint looks up the value of a local Uint64Flag, returns0 if not found

func (*Command)Uint16 ¶added inv3.2.0

func (cmd *Command) Uint16(namestring)uint16

Uint16 looks up the value of a local Uint16Flag, returns0 if not found

func (*Command)Uint16Arg ¶added inv3.2.0

func (c *Command) Uint16Arg(namestring)uint16

func (*Command)Uint16Args ¶added inv3.2.0

func (c *Command) Uint16Args(namestring) []uint16

func (*Command)Uint16Slice ¶added inv3.2.0

func (cmd *Command) Uint16Slice(namestring) []uint16

Uint16Slice looks up the value of a local Uint16SliceFlag, returnsnil if not found

func (*Command)Uint32 ¶added inv3.2.0

func (cmd *Command) Uint32(namestring)uint32

Uint32 looks up the value of a local Uint32Flag, returns0 if not found

func (*Command)Uint32Arg ¶added inv3.2.0

func (c *Command) Uint32Arg(namestring)uint32

func (*Command)Uint32Args ¶added inv3.2.0

func (c *Command) Uint32Args(namestring) []uint32

func (*Command)Uint32Slice ¶added inv3.2.0

func (cmd *Command) Uint32Slice(namestring) []uint32

Uint32Slice looks up the value of a local Uint32SliceFlag, returnsnil if not found

func (*Command)Uint64 ¶added inv3.2.0

func (cmd *Command) Uint64(namestring)uint64

Uint64 looks up the value of a local Uint64Flag, returns0 if not found

func (*Command)Uint64Arg ¶added inv3.2.0

func (c *Command) Uint64Arg(namestring)uint64

func (*Command)Uint64Args ¶added inv3.2.0

func (c *Command) Uint64Args(namestring) []uint64

func (*Command)Uint64Slice ¶added inv3.2.0

func (cmd *Command) Uint64Slice(namestring) []uint64

Uint64Slice looks up the value of a local Uint64SliceFlag, returnsnil if not found

func (*Command)Uint8 ¶added inv3.2.0

func (cmd *Command) Uint8(namestring)uint8

Uint8 looks up the value of a local Uint8Flag, returns0 if not found

func (*Command)Uint8Arg ¶added inv3.2.0

func (c *Command) Uint8Arg(namestring)uint8

func (*Command)Uint8Args ¶added inv3.2.0

func (c *Command) Uint8Args(namestring) []uint8

func (*Command)Uint8Slice ¶added inv3.2.0

func (cmd *Command) Uint8Slice(namestring) []uint8

Uint8Slice looks up the value of a local Uint8SliceFlag, returnsnil if not found

func (*Command)UintArg ¶added inv3.2.0

func (c *Command) UintArg(namestring)uint

func (*Command)UintArgs ¶added inv3.2.0

func (c *Command) UintArgs(namestring) []uint

func (*Command)UintSlice ¶

func (cmd *Command) UintSlice(namestring) []uint

UintSlice looks up the value of a local UintSliceFlag, returnsnil if not found

func (*Command)Value ¶

func (cmd *Command) Value(namestring) interface{}

Value returns the value of the flag corresponding to `name`

func (*Command)VisibleCategories ¶

func (cmd *Command) VisibleCategories() []CommandCategory

VisibleCategories returns a slice of categories and commands that areHidden=false

func (*Command)VisibleCommands ¶

func (cmd *Command) VisibleCommands() []*Command

VisibleCommands returns a slice of the Commands with Hidden=false

func (*Command)VisibleFlagCategories ¶

func (cmd *Command) VisibleFlagCategories() []VisibleFlagCategory

VisibleFlagCategories returns a slice containing all the visible flag categories with the flags they contain

func (*Command)VisibleFlags ¶

func (cmd *Command) VisibleFlags() []Flag

VisibleFlags returns a slice of the Flags with Hidden=false

func (*Command)VisiblePersistentFlags ¶

func (cmd *Command) VisiblePersistentFlags() []Flag

VisiblePersistentFlags returns a slice ofLocalFlag with Persistent=true and Hidden=false.

typeCommandCategories ¶

type CommandCategories interface {// AddCommand adds a command to a category, creating a new category if necessary.AddCommand(categorystring, command *Command)// Categories returns a slice of categories sorted by nameCategories() []CommandCategory}

CommandCategories interface allows for category manipulation

typeCommandCategory ¶

type CommandCategory interface {// Name returns the category name stringName()string// VisibleCommands returns a slice of the Commands with Hidden=falseVisibleCommands() []*Command}

CommandCategory is a category containing commands.

typeCommandNotFoundFunc ¶

type CommandNotFoundFunc func(context.Context, *Command,string)

CommandNotFoundFunc is executed if the proper command cannot be found

typeConfigureShellCompletionCommand ¶added inv3.3.0

type ConfigureShellCompletionCommand func(*Command)

ConfigureShellCompletionCommand is a function to configure a shell completion command

typeCountable ¶

type Countable interface {Count()int}

Countable is an interface to enable detection of flag values which supportrepetitive flags

typeDocGenerationFlag ¶

type DocGenerationFlag interface {// TakesValue returns true if the flag takes a value, otherwise falseTakesValue()bool// GetUsage returns the usage string for the flagGetUsage()string// GetValue returns the flags value as string representation and an empty// string if the flag takes no value at all.GetValue()string// GetDefaultText returns the default text for this flagGetDefaultText()string// GetEnvVars returns the env vars for this flagGetEnvVars() []string// IsDefaultVisible returns whether the default value should be shown in// help textIsDefaultVisible()bool// TypeName to detect if a flag is a string, bool, etc.TypeName()string}

DocGenerationFlag is an interface that allows documentation generation for the flag

typeDocGenerationMultiValueFlag ¶

type DocGenerationMultiValueFlag interface {DocGenerationFlag// IsMultiValueFlag returns true for flags that can be given multiple times.IsMultiValueFlag()bool}

DocGenerationMultiValueFlag extends DocGenerationFlag for slice/map based flags.

typeDurationFlag ¶

type DurationFlag =FlagBase[time.Duration,NoConfig, durationValue]

typeEnvValueSource ¶

type EnvValueSource interface {IsFromEnv()boolKey()string}

EnvValueSource is to specifically detect env sources whenprinting help text

typeErrorFormatter ¶

type ErrorFormatter interface {Format(sfmt.State, verbrune)}

ErrorFormatter is the interface that will suitably format the error output

typeExitCoder ¶

type ExitCoder interface {errorExitCode()int}

ExitCoder is the interface checked by `App` and `Command` for a custom exitcode

funcExit ¶

func Exit(message interface{}, exitCodeint)ExitCoder

Exit wraps a message and exit code into an error, which by default ishandled with a call to os.Exit during default error handling.

This is the simplest way to trigger a non-zero exit code for an App withouthaving to call os.Exit manually. During testing, this behavior can be avoidedby overriding the ExitErrHandler function on an App or the package-globalOsExiter function.

typeExitErrHandlerFunc ¶

type ExitErrHandlerFunc func(context.Context, *Command,error)

ExitErrHandlerFunc is executed if provided in order to handle exitError valuesreturned by Actions and Before/After functions.

typeFlag ¶

type Flag interface {fmt.Stringer// Retrieve the value of the FlagGet()any// Lifecycle methods.// flag callback prior to parsingPreParse()error// flag callback post parsingPostParse()error// Apply Flag settings to the given flag setSet(string,string)error// All possible names for this flagNames() []string// Whether the flag has been set or notIsSet()bool}

Flag is a common interface related to parsing flags in cli.For more advanced flag parsing techniques, it is recommended thatthis interface be implemented.

var GenerateShellCompletionFlagFlag = &BoolFlag{Name:   "generate-shell-completion",Hidden:true,}

GenerateShellCompletionFlag enables shell completion

var HelpFlagFlag = &BoolFlag{Name:        "help",Aliases:     []string{"h"},Usage:       "show help",HideDefault:true,Local:true,}

HelpFlag prints the help for all commands and subcommands.Set to nil to disable the flag. The subcommandwill still be added unless HideHelp or HideHelpCommand is set to true.

var VersionFlagFlag = &BoolFlag{Name:        "version",Aliases:     []string{"v"},Usage:       "print the version",HideDefault:true,Local:true,}

VersionFlag prints the version for the application

typeFlagBase ¶

type FlagBase[Tany, Cany, VCValueCreator[T, C]] struct {Namestring                                   `json:"name"`// name of the flagCategorystring                                   `json:"category"`// category of the flag, if anyDefaultTextstring                                   `json:"defaultText"`// default text of the flag for usage purposesHideDefaultbool                                     `json:"hideDefault"`// whether to hide the default value in outputUsagestring                                   `json:"usage"`// usage string for help outputSourcesValueSourceChain                         `json:"-"`// sources to load flag value fromRequiredbool                                     `json:"required"`// whether the flag is required or notHiddenbool                                     `json:"hidden"`// whether to hide the flag in help outputLocalbool                                     `json:"local"`// whether the flag needs to be applied to subcommands as wellValue            T                                        `json:"defaultValue"`// default value for this flag if not set by from any sourceDestination      *T                                       `json:"-"`// destination pointer for value when setAliases          []string                                 `json:"aliases"`// Aliases that are allowed for this flagTakesFilebool                                     `json:"takesFileArg"`// whether this flag takes a file argument, mainly for shell completion purposesAction           func(context.Context, *Command, T)error `json:"-"`// Action callback to be called when flag is setConfig           C                                        `json:"config"`// Additional/Custom configuration associated with this flag typeOnlyOncebool                                     `json:"onlyOnce"`// whether this flag can be duplicated on the command lineValidator        func(T)error                            `json:"-"`// custom function to validate this flag valueValidateDefaultsbool                                     `json:"validateDefaults"`// whether to validate defaults or not// contains filtered or unexported fields}

FlagBase [T,C,VC] is a generic flag base which can be usedas a boilerplate to implement the most common interfacesused by urfave/cli.

T specifies the typeC specifies the configuration required(if any for that flag type)VC specifies the value creator which creates the flag.Value emulation

func (*FlagBase[T, C, VC])Count ¶

func (f *FlagBase[T, C, VC]) Count()int

Count returns the number of times this flag has been invoked

func (*FlagBase[T, C, V])Get ¶

func (f *FlagBase[T, C, V]) Get()any

func (*FlagBase[T, C, V])GetCategory ¶

func (f *FlagBase[T, C, V]) GetCategory()string

GetCategory returns the category of the flag

func (*FlagBase[T, C, V])GetDefaultText ¶

func (f *FlagBase[T, C, V]) GetDefaultText()string

GetDefaultText returns the default text for this flag

func (*FlagBase[T, C, V])GetEnvVars ¶

func (f *FlagBase[T, C, V]) GetEnvVars() []string

GetEnvVars returns the env vars for this flag

func (*FlagBase[T, C, V])GetUsage ¶

func (f *FlagBase[T, C, V]) GetUsage()string

GetUsage returns the usage string for the flag

func (*FlagBase[T, C, V])GetValue ¶

func (f *FlagBase[T, C, V]) GetValue()string

GetValue returns the flags value as string representation and an emptystring if the flag takes no value at all.

func (*FlagBase[T, C, VC])IsBoolFlag ¶

func (f *FlagBase[T, C, VC]) IsBoolFlag()bool

IsBoolFlag returns whether the flag doesnt need to accept args

func (*FlagBase[T, C, V])IsDefaultVisible ¶

func (f *FlagBase[T, C, V]) IsDefaultVisible()bool

IsDefaultVisible returns true if the flag is not hidden, otherwise false

func (*FlagBase[T, C, VC])IsLocal ¶

func (f *FlagBase[T, C, VC]) IsLocal()bool

IsLocal returns false if flag needs to be persistent across subcommands

func (*FlagBase[T, C, VC])IsMultiValueFlag ¶

func (f *FlagBase[T, C, VC]) IsMultiValueFlag()bool

IsMultiValueFlag returns true if the value type T can take multiplevalues from cmd line. This is true for slice and map type flags

func (*FlagBase[T, C, V])IsRequired ¶

func (f *FlagBase[T, C, V]) IsRequired()bool

IsRequired returns whether or not the flag is required

func (*FlagBase[T, C, V])IsSet ¶

func (f *FlagBase[T, C, V]) IsSet()bool

IsSet returns whether or not the flag has been set through env or file

func (*FlagBase[T, C, V])IsVisible ¶

func (f *FlagBase[T, C, V]) IsVisible()bool

IsVisible returns true if the flag is not hidden, otherwise false

func (*FlagBase[T, C, V])Names ¶

func (f *FlagBase[T, C, V]) Names() []string

Names returns the names of the flag

func (*FlagBase[T, C, V])PostParse ¶

func (f *FlagBase[T, C, V]) PostParse()error

PostParse populates the flag given the flag set and environment

func (*FlagBase[T, C, V])PreParse ¶

func (f *FlagBase[T, C, V]) PreParse()error

func (*FlagBase[T, C, V])RunAction ¶

func (f *FlagBase[T, C, V]) RunAction(ctxcontext.Context, cmd *Command)error

RunAction executes flag action if set

func (*FlagBase[T, C, V])Set ¶

func (f *FlagBase[T, C, V]) Set(_string, valstring)error

Set applies given value from string

func (*FlagBase[T, C, V])SetCategory ¶

func (f *FlagBase[T, C, V]) SetCategory(cstring)

func (*FlagBase[T, C, V])String ¶

func (f *FlagBase[T, C, V]) String()string

String returns a readable representation of this value (for usage defaults)

func (*FlagBase[T, C, V])TakesValue ¶

func (f *FlagBase[T, C, V]) TakesValue()bool

TakesValue returns true if the flag takes a value, otherwise false

func (*FlagBase[T, C, V])TypeName ¶

func (f *FlagBase[T, C, V]) TypeName()string

TypeName returns the type of the flag.

typeFlagCategories ¶

type FlagCategories interface {// AddFlags adds a flag to a category, creating a new category if necessary.AddFlag(categorystring, flFlag)// VisibleCategories returns a slice of visible flag categories sorted by nameVisibleCategories() []VisibleFlagCategory}

FlagCategories interface allows for category manipulation

typeFlagEnvHintFunc ¶

type FlagEnvHintFunc func(envVars []string, strstring)string

FlagEnvHintFunc is used by the default FlagStringFunc to annotate flag helpwith the environment variable details.

var FlagEnvHinterFlagEnvHintFunc = withEnvHint

FlagEnvHinter annotates flag help message with the environment variabledetails. This is used by the default FlagStringer.

typeFlagFileHintFunc ¶

type FlagFileHintFunc func(filePath, strstring)string

FlagFileHintFunc is used by the default FlagStringFunc to annotate flag helpwith the file path details.

var FlagFileHinterFlagFileHintFunc = withFileHint

FlagFileHinter annotates flag help message with the environment variabledetails. This is used by the default FlagStringer.

typeFlagNamePrefixFunc ¶

type FlagNamePrefixFunc func(fullName []string, placeholderstring)string

FlagNamePrefixFunc is used by the default FlagStringFunc to create prefixtext for a flag's full name.

var FlagNamePrefixerFlagNamePrefixFunc = prefixedNames

FlagNamePrefixer converts a full flag name and its placeholder into the helpmessage flag prefix. This is used by the default FlagStringer.

typeFlagStringFunc ¶

type FlagStringFunc func(Flag)string

FlagStringFunc is used by the help generation to display a flag, which isexpected to be a single line.

var FlagStringerFlagStringFunc = stringifyFlag

FlagStringer converts a flag definition to a string. This is used by helpto display a flag.

typeFlagsByName ¶

type FlagsByName []Flag

FlagsByName is a slice of Flag.

func (FlagsByName)Len ¶

func (fFlagsByName) Len()int

func (FlagsByName)Less ¶

func (fFlagsByName) Less(i, jint)bool

func (FlagsByName)Swap ¶

func (fFlagsByName) Swap(i, jint)

typeFloat32Arg ¶added inv3.3.0

type Float32Arg =ArgumentBase[float32,NoConfig, floatValue[float32]]

typeFloat32Args ¶added inv3.3.0

type Float32Args =ArgumentsBase[float32,NoConfig, floatValue[float32]]

typeFloat32Flag ¶added inv3.3.0

type Float32Flag =FlagBase[float32,NoConfig, floatValue[float32]]

typeFloat32Slice ¶added inv3.3.0

type Float32Slice =SliceBase[float32,NoConfig, floatValue[float32]]

typeFloat32SliceFlag ¶added inv3.3.0

type Float32SliceFlag =FlagBase[[]float32,NoConfig,Float32Slice]

typeFloat64Arg ¶added inv3.3.0

type Float64Arg =ArgumentBase[float64,NoConfig, floatValue[float64]]

typeFloat64Args ¶added inv3.3.0

type Float64Args =ArgumentsBase[float64,NoConfig, floatValue[float64]]

typeFloat64Flag ¶added inv3.3.0

type Float64Flag =FlagBase[float64,NoConfig, floatValue[float64]]

typeFloat64Slice ¶added inv3.3.0

type Float64Slice =SliceBase[float64,NoConfig, floatValue[float64]]

typeFloat64SliceFlag ¶added inv3.3.0

type Float64SliceFlag =FlagBase[[]float64,NoConfig,Float64Slice]

typeFloatArg ¶

type FloatArg =ArgumentBase[float64,NoConfig, floatValue[float64]]

typeFloatArgs ¶added inv3.2.0

type FloatArgs =ArgumentsBase[float64,NoConfig, floatValue[float64]]

typeFloatFlag ¶

type FloatFlag =FlagBase[float64,NoConfig, floatValue[float64]]

typeFloatSlice ¶

type FloatSlice =SliceBase[float64,NoConfig, floatValue[float64]]

typeFloatSliceFlag ¶

type FloatSliceFlag =FlagBase[[]float64,NoConfig,FloatSlice]

typeGenericFlag ¶

type GenericFlag =FlagBase[Value,NoConfig, genericValue]

typeInt16Arg ¶added inv3.2.0

type Int16Arg =ArgumentBase[int16,IntegerConfig, intValue[int16]]

typeInt16Args ¶added inv3.2.0

type Int16Args =ArgumentsBase[int16,IntegerConfig, intValue[int16]]

typeInt16Flag ¶added inv3.2.0

type Int16Flag =FlagBase[int16,IntegerConfig, intValue[int16]]

typeInt16Slice ¶added inv3.2.0

type Int16Slice =SliceBase[int16,IntegerConfig, intValue[int16]]

typeInt16SliceFlag ¶added inv3.2.0

type Int16SliceFlag =FlagBase[[]int16,IntegerConfig,Int16Slice]

typeInt32Arg ¶added inv3.2.0

type Int32Arg =ArgumentBase[int32,IntegerConfig, intValue[int32]]

typeInt32Args ¶added inv3.2.0

type Int32Args =ArgumentsBase[int32,IntegerConfig, intValue[int32]]

typeInt32Flag ¶added inv3.2.0

type Int32Flag =FlagBase[int32,IntegerConfig, intValue[int32]]

typeInt32Slice ¶added inv3.2.0

type Int32Slice =SliceBase[int32,IntegerConfig, intValue[int32]]

typeInt32SliceFlag ¶added inv3.2.0

type Int32SliceFlag =FlagBase[[]int32,IntegerConfig,Int32Slice]

typeInt64Arg ¶added inv3.2.0

type Int64Arg =ArgumentBase[int64,IntegerConfig, intValue[int64]]

typeInt64Args ¶added inv3.2.0

type Int64Args =ArgumentsBase[int64,IntegerConfig, intValue[int64]]

typeInt64Flag ¶added inv3.2.0

type Int64Flag =FlagBase[int64,IntegerConfig, intValue[int64]]

typeInt64Slice ¶added inv3.2.0

type Int64Slice =SliceBase[int64,IntegerConfig, intValue[int64]]

typeInt64SliceFlag ¶added inv3.2.0

type Int64SliceFlag =FlagBase[[]int64,IntegerConfig,Int64Slice]

typeInt8Arg ¶added inv3.2.0

type Int8Arg =ArgumentBase[int8,IntegerConfig, intValue[int8]]

typeInt8Args ¶added inv3.2.0

type Int8Args =ArgumentsBase[int8,IntegerConfig, intValue[int8]]

typeInt8Flag ¶added inv3.2.0

type Int8Flag =FlagBase[int8,IntegerConfig, intValue[int8]]

typeInt8Slice ¶added inv3.2.0

type Int8Slice =SliceBase[int8,IntegerConfig, intValue[int8]]

typeInt8SliceFlag ¶added inv3.2.0

type Int8SliceFlag =FlagBase[[]int8,IntegerConfig,Int8Slice]

typeIntArg ¶

type IntArg =ArgumentBase[int,IntegerConfig, intValue[int]]

typeIntArgs ¶added inv3.2.0

type IntArgs =ArgumentsBase[int,IntegerConfig, intValue[int]]

typeIntFlag ¶

type IntFlag =FlagBase[int,IntegerConfig, intValue[int]]

typeIntSlice ¶

type IntSlice =SliceBase[int,IntegerConfig, intValue[int]]

typeIntSliceFlag ¶

type IntSliceFlag =FlagBase[[]int,IntegerConfig,IntSlice]

typeIntegerConfig ¶

type IntegerConfig struct {Baseint}

IntegerConfig is the configuration for all integer type flags

typeInvalidFlagAccessFunc ¶

type InvalidFlagAccessFunc func(context.Context, *Command,string)

InvalidFlagAccessFunc is executed when an invalid flag is accessed from the context.

typeLocalFlag ¶

type LocalFlag interface {IsLocal()bool}

LocalFlag is an interface to enable detection of flags which are localto current command

typeMapBase ¶

type MapBase[Tany, Cany, VCValueCreator[T, C]] struct {// contains filtered or unexported fields}

MapBase wraps map[string]T to satisfy flag.Value

funcNewMapBase ¶

func NewMapBase[Tany, Cany, VCValueCreator[T, C]](defaults map[string]T) *MapBase[T, C, VC]

NewMapBase makes a *MapBase with default values

func (MapBase[T, C, VC])Create ¶

func (iMapBase[T, C, VC]) Create(val map[string]T, p *map[string]T, c C)Value

func (*MapBase[T, C, VC])Get ¶

func (i *MapBase[T, C, VC]) Get() interface{}

Get returns the mapping of values set by this flag

func (*MapBase[T, C, VC])Serialize ¶

func (i *MapBase[T, C, VC]) Serialize()string

Serialize allows MapBase to fulfill Serializer

func (*MapBase[T, C, VC])Set ¶

func (i *MapBase[T, C, VC]) Set(valuestring)error

Set parses the value and appends it to the list of values

func (*MapBase[T, C, VC])String ¶

func (i *MapBase[T, C, VC]) String()string

String returns a readable representation of this value (for usage defaults)

func (MapBase[T, C, VC])ToString ¶

func (iMapBase[T, C, VC]) ToString(t map[string]T)string

func (*MapBase[T, C, VC])Value ¶

func (i *MapBase[T, C, VC]) Value() map[string]T

Value returns the mapping of values set by this flag

typeMapSource ¶

type MapSource interface {fmt.Stringerfmt.GoStringer// Lookup returns the value from the source based on key// and if it was found// or returns an empty string and falseLookup(string) (any,bool)}

MapSource is a source which can be used to look up a valuebased on a keytypically for use with a cli.Flag

funcNewMapSource ¶

func NewMapSource(namestring, m map[any]any)MapSource

typeMultiError ¶

type MultiError interface {errorErrors() []error}

MultiError is an error that wraps multiple errors.

typeMutuallyExclusiveFlags ¶

type MutuallyExclusiveFlags struct {// Flag listFlags [][]Flag// whether this group is requiredRequiredbool// Category to apply to all flags within groupCategorystring}

MutuallyExclusiveFlags defines a mutually exclusive flag groupMultiple option paths can be provided out of whichonly one can be defined on cmdlineSo for example[ --foo | [ --bar something --darth somethingelse ] ]

typeNoConfig ¶

type NoConfig struct{}

NoConfig is for flags which dont need a custom configuration

typeOnUsageErrorFunc ¶

type OnUsageErrorFunc func(ctxcontext.Context, cmd *Command, errerror, isSubcommandbool)error

OnUsageErrorFunc is executed if a usage error occurs. This is useful for displayingcustomized usage error messages. This function is able to replace theoriginal error messages. If this function is not set, the "Incorrect usage"is displayed and the execution is interrupted.

typeRequiredFlag ¶

type RequiredFlag interface {// whether the flag is a required flag or notIsRequired()bool}

RequiredFlag is an interface that allows us to mark flags as requiredit allows flags required flags to be backwards compatible with the Flag interface

typeSerializer ¶

type Serializer interface {Serialize()string}

Serializer is used to circumvent the limitations of flag.FlagSet.Set

typeShellCompleteFunc ¶

type ShellCompleteFunc func(context.Context, *Command)

ShellCompleteFunc is an action to execute when the shell completion flag is set

typeSliceBase ¶

type SliceBase[Tany, Cany, VCValueCreator[T, C]] struct {// contains filtered or unexported fields}

SliceBase wraps []T to satisfy flag.Value

funcNewSliceBase ¶

func NewSliceBase[Tany, Cany, VCValueCreator[T, C]](defaults ...T) *SliceBase[T, C, VC]

NewSliceBase makes a *SliceBase with default values

func (SliceBase[T, C, VC])Create ¶

func (iSliceBase[T, C, VC]) Create(val []T, p *[]T, c C)Value

func (*SliceBase[T, C, VC])Get ¶

func (i *SliceBase[T, C, VC]) Get() interface{}

Get returns the slice of values set by this flag

func (*SliceBase[T, C, VC])Serialize ¶

func (i *SliceBase[T, C, VC]) Serialize()string

Serialize allows SliceBase to fulfill Serializer

func (*SliceBase[T, C, VC])Set ¶

func (i *SliceBase[T, C, VC]) Set(valuestring)error

Set parses the value and appends it to the list of values

func (*SliceBase[T, C, VC])String ¶

func (i *SliceBase[T, C, VC]) String()string

String returns a readable representation of this value (for usage defaults)

func (SliceBase[T, C, VC])ToString ¶

func (iSliceBase[T, C, VC]) ToString(t []T)string

func (*SliceBase[T, C, VC])Value ¶

func (i *SliceBase[T, C, VC]) Value() []T

Value returns the slice of values set by this flag

typeStringArg ¶

type StringArg =ArgumentBase[string,StringConfig, stringValue]

typeStringArgs ¶added inv3.2.0

type StringArgs =ArgumentsBase[string,StringConfig, stringValue]

typeStringConfig ¶

type StringConfig struct {// Whether to trim whitespace of parsed valueTrimSpacebool}

StringConfig defines the configuration for string flags

typeStringFlag ¶

type StringFlag =FlagBase[string,StringConfig, stringValue]

typeStringMap ¶

type StringMap =MapBase[string,StringConfig, stringValue]

typeStringMapArgs ¶added inv3.2.0

type StringMapArgs =ArgumentBase[map[string]string,StringConfig,StringMap]

typeStringMapFlag ¶

type StringMapFlag =FlagBase[map[string]string,StringConfig,StringMap]

typeStringSlice ¶

type StringSlice =SliceBase[string,StringConfig, stringValue]

typeStringSliceFlag ¶

type StringSliceFlag =FlagBase[[]string,StringConfig,StringSlice]

typeSuggestCommandFunc ¶

type SuggestCommandFunc func(commands []*Command, providedstring)string

typeSuggestFlagFunc ¶

type SuggestFlagFunc func(flags []Flag, providedstring, hideHelpbool)string

typeTimestampArg ¶

type TimestampArg =ArgumentBase[time.Time,TimestampConfig, timestampValue]

typeTimestampArgs ¶added inv3.2.0

type TimestampArgs =ArgumentsBase[time.Time,TimestampConfig, timestampValue]

typeTimestampConfig ¶

type TimestampConfig struct {Timezone *time.Location// Available layouts for flag value.//// Note that value for formats with missing year/date will be interpreted as current year/date respectively.//// Read more about time layouts:https://pkg.go.dev/time#pkg-constantsLayouts []string}

TimestampConfig defines the config for timestamp flags

typeTimestampFlag ¶

type TimestampFlag =FlagBase[time.Time,TimestampConfig, timestampValue]

typeUint16Arg ¶added inv3.2.0

type Uint16Arg =ArgumentBase[uint16,IntegerConfig, uintValue[uint16]]

typeUint16Args ¶added inv3.2.0

type Uint16Args =ArgumentsBase[uint16,IntegerConfig, uintValue[uint16]]

typeUint16Flag ¶added inv3.2.0

type Uint16Flag =FlagBase[uint16,IntegerConfig, uintValue[uint16]]

typeUint16Slice ¶added inv3.2.0

type Uint16Slice =SliceBase[uint16,IntegerConfig, uintValue[uint16]]

typeUint16SliceFlag ¶added inv3.2.0

type Uint16SliceFlag =FlagBase[[]uint16,IntegerConfig,Uint16Slice]

typeUint32Arg ¶added inv3.2.0

type Uint32Arg =ArgumentBase[uint32,IntegerConfig, uintValue[uint32]]

typeUint32Args ¶added inv3.2.0

type Uint32Args =ArgumentsBase[uint32,IntegerConfig, uintValue[uint32]]

typeUint32Flag ¶added inv3.2.0

type Uint32Flag =FlagBase[uint32,IntegerConfig, uintValue[uint32]]

typeUint32Slice ¶added inv3.2.0

type Uint32Slice =SliceBase[uint32,IntegerConfig, uintValue[uint32]]

typeUint32SliceFlag ¶added inv3.2.0

type Uint32SliceFlag =FlagBase[[]uint32,IntegerConfig,Uint32Slice]

typeUint64Arg ¶added inv3.2.0

type Uint64Arg =ArgumentBase[uint64,IntegerConfig, uintValue[uint64]]

typeUint64Args ¶added inv3.2.0

type Uint64Args =ArgumentsBase[uint64,IntegerConfig, uintValue[uint64]]

typeUint64Flag ¶added inv3.2.0

type Uint64Flag =FlagBase[uint64,IntegerConfig, uintValue[uint64]]

typeUint64Slice ¶added inv3.2.0

type Uint64Slice =SliceBase[uint64,IntegerConfig, uintValue[uint64]]

typeUint64SliceFlag ¶added inv3.2.0

type Uint64SliceFlag =FlagBase[[]uint64,IntegerConfig,Uint64Slice]

typeUint8Arg ¶added inv3.2.0

type Uint8Arg =ArgumentBase[uint8,IntegerConfig, uintValue[uint8]]

typeUint8Args ¶added inv3.2.0

type Uint8Args =ArgumentsBase[uint8,IntegerConfig, uintValue[uint8]]

typeUint8Flag ¶added inv3.2.0

type Uint8Flag =FlagBase[uint8,IntegerConfig, uintValue[uint8]]

typeUint8Slice ¶added inv3.2.0

type Uint8Slice =SliceBase[uint8,IntegerConfig, uintValue[uint8]]

typeUint8SliceFlag ¶added inv3.2.0

type Uint8SliceFlag =FlagBase[[]uint8,IntegerConfig,Uint8Slice]

typeUintArg ¶

type UintArg =ArgumentBase[uint,IntegerConfig, uintValue[uint]]

typeUintArgs ¶added inv3.2.0

type UintArgs =ArgumentsBase[uint,IntegerConfig, uintValue[uint]]

typeUintFlag ¶

type UintFlag =FlagBase[uint,IntegerConfig, uintValue[uint]]

typeUintSlice ¶

type UintSlice =SliceBase[uint,IntegerConfig, uintValue[uint]]

typeUintSliceFlag ¶

type UintSliceFlag =FlagBase[[]uint,IntegerConfig,UintSlice]

typeValue ¶

type Value interface {flag.Valueflag.Getter}

Value represents a value as used by cli.For now it implements the golang flag.Value interface

typeValueCreator ¶

type ValueCreator[Tany, Cany] interface {Create(T, *T, C)ValueToString(T)string}

ValueCreator is responsible for creating a flag.Value emulationas well as custom formatting

T specifies the typeC specifies the config for the type

typeValueSource ¶

type ValueSource interface {fmt.Stringerfmt.GoStringer// Lookup returns the value from the source and if it was found// or returns an empty string and falseLookup() (string,bool)}

ValueSource is a source which can be used to look up a value,typically for use with a cli.Flag

funcEnvVar ¶

func EnvVar(keystring)ValueSource

funcFile ¶

func File(pathstring)ValueSource

funcNewMapValueSource ¶

func NewMapValueSource(keystring, msMapSource)ValueSource

typeValueSourceChain ¶

type ValueSourceChain struct {Chain []ValueSource}

ValueSourceChain contains an ordered series of ValueSource thatallows for lookup where the first ValueSource to resolve isreturned

funcEnvVars ¶

func EnvVars(keys ...string)ValueSourceChain

EnvVars is a helper function to encapsulate a number ofenvVarValueSource together as a ValueSourceChain

funcFiles ¶

func Files(paths ...string)ValueSourceChain

Files is a helper function to encapsulate a number offileValueSource together as a ValueSourceChain

funcNewValueSourceChain ¶

func NewValueSourceChain(src ...ValueSource)ValueSourceChain

func (*ValueSourceChain)Append ¶

func (vsc *ValueSourceChain) Append(otherValueSourceChain)

func (*ValueSourceChain)EnvKeys ¶

func (vsc *ValueSourceChain) EnvKeys() []string

func (*ValueSourceChain)GoString ¶

func (vsc *ValueSourceChain) GoString()string

func (*ValueSourceChain)Lookup ¶

func (vsc *ValueSourceChain) Lookup() (string,bool)

func (*ValueSourceChain)LookupWithSource ¶

func (vsc *ValueSourceChain) LookupWithSource() (string,ValueSource,bool)

func (*ValueSourceChain)String ¶

func (vsc *ValueSourceChain) String()string

typeVisibleFlag ¶

type VisibleFlag interface {// IsVisible returns true if the flag is not hidden, otherwise falseIsVisible()bool}

VisibleFlag is an interface that allows to check if a flag is visible

typeVisibleFlagCategory ¶

type VisibleFlagCategory interface {// Name returns the category name stringName()string// Flags returns a slice of VisibleFlag sorted by nameFlags() []Flag}

VisibleFlagCategory is a category containing flags.

Source Files¶

View all Source files

Directories¶

Path	Synopsis
examples
example-cli
example-hello-world
scripts

?	: This menu
/	: Search site
f orF	: Jump to
y orY	: Canonical URL

Movatterモバイル変換

Details

Repository

Links

README¶

Welcome to urfave/cli

Documentation

Support

License

Documentation¶

Overview¶

Index¶

Examples¶

Constants¶

Variables¶

Functions¶

funcDefaultAppComplete¶

funcDefaultCompleteWithFlags¶

funcFlagNames¶

funcHandleExitCoder¶

funcShowAppHelp¶

funcShowAppHelpAndExit¶

funcShowCommandHelp¶

funcShowCommandHelpAndExit¶

funcShowSubcommandHelp¶

funcShowSubcommandHelpAndExit¶

funcShowVersion¶

Types¶

typeActionFunc¶

typeActionableFlag¶

typeAfterFunc¶

typeArgs¶

typeArgument¶

typeArgumentBase¶

func (*ArgumentBase[T, C, VC])Get¶added inv3.2.0

func (*ArgumentBase[T, C, VC])HasName¶added inv3.2.0

func (*ArgumentBase[T, C, VC])Parse¶

func (*ArgumentBase[T, C, VC])Usage¶

typeArgumentsBase¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])Get¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])HasName¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])Parse¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])Usage¶added inv3.2.0

typeBeforeFunc¶

typeBoolConfig¶

typeBoolFlag¶

typeBoolWithInverseFlag¶

func (*BoolWithInverseFlag)Count¶

func (*BoolWithInverseFlag)Get¶

func (*BoolWithInverseFlag)GetCategory¶

func (*BoolWithInverseFlag)GetDefaultText¶

func (*BoolWithInverseFlag)GetEnvVars¶

func (*BoolWithInverseFlag)GetUsage¶

func (*BoolWithInverseFlag)GetValue¶

func (*BoolWithInverseFlag)IsBoolFlag¶

func (*BoolWithInverseFlag)IsDefaultVisible¶

func (*BoolWithInverseFlag)IsLocal¶added inv3.3.7

func (*BoolWithInverseFlag)IsRequired¶added inv3.3.5

func (*BoolWithInverseFlag)IsSet¶

func (*BoolWithInverseFlag)IsVisible¶added inv3.3.5

func (*BoolWithInverseFlag)Names¶

func (*BoolWithInverseFlag)PostParse¶

func (*BoolWithInverseFlag)PreParse¶

func (*BoolWithInverseFlag)RunAction¶

func (*BoolWithInverseFlag)Set¶

func (*BoolWithInverseFlag)SetCategory¶

func (*BoolWithInverseFlag)String¶

func (*BoolWithInverseFlag)TakesValue¶

func (*BoolWithInverseFlag)TypeName¶

typeCategorizableFlag¶

typeCommand¶

func (*Command)Args¶

func (*Command)Bool¶

func (*Command)Command¶

func (*Command)Count¶

func (*Command)Duration¶

func (*Command)FlagNames¶

func (*Command)Float¶

func (*Command)Float32¶added inv3.3.0

func (*Command)Float32Arg¶added inv3.3.0

README ¶

funcDefaultAppComplete ¶

funcDefaultCompleteWithFlags ¶

funcFlagNames ¶

funcHandleExitCoder ¶

funcShowAppHelp ¶

funcShowAppHelpAndExit ¶

funcShowCommandHelp ¶

funcShowCommandHelpAndExit ¶

funcShowSubcommandHelp ¶

funcShowSubcommandHelpAndExit ¶

funcShowVersion ¶

typeActionFunc ¶

typeActionableFlag ¶

typeAfterFunc ¶

typeArgs ¶

typeArgument ¶

typeArgumentBase ¶

func (*ArgumentBase[T, C, VC])Get ¶added inv3.2.0

func (*ArgumentBase[T, C, VC])HasName ¶added inv3.2.0

func (*ArgumentBase[T, C, VC])Parse ¶

func (*ArgumentBase[T, C, VC])Usage ¶

typeArgumentsBase ¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])Get ¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])HasName ¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])Parse ¶added inv3.2.0

func (*ArgumentsBase[T, C, VC])Usage ¶added inv3.2.0

typeBeforeFunc ¶

typeBoolConfig ¶

typeBoolFlag ¶

typeBoolWithInverseFlag ¶

func (*BoolWithInverseFlag)Count ¶

func (*BoolWithInverseFlag)Get ¶

func (*BoolWithInverseFlag)GetCategory ¶

func (*BoolWithInverseFlag)GetDefaultText ¶

func (*BoolWithInverseFlag)GetEnvVars ¶

func (*BoolWithInverseFlag)GetUsage ¶

func (*BoolWithInverseFlag)GetValue ¶

func (*BoolWithInverseFlag)IsBoolFlag ¶

func (*BoolWithInverseFlag)IsDefaultVisible ¶

func (*BoolWithInverseFlag)IsLocal ¶added inv3.3.7

func (*BoolWithInverseFlag)IsRequired ¶added inv3.3.5

func (*BoolWithInverseFlag)IsSet ¶

func (*BoolWithInverseFlag)IsVisible ¶added inv3.3.5

func (*BoolWithInverseFlag)Names ¶

func (*BoolWithInverseFlag)PostParse ¶

func (*BoolWithInverseFlag)PreParse ¶

func (*BoolWithInverseFlag)RunAction ¶

func (*BoolWithInverseFlag)Set ¶

func (*BoolWithInverseFlag)SetCategory ¶

func (*BoolWithInverseFlag)String ¶

func (*BoolWithInverseFlag)TakesValue ¶

func (*BoolWithInverseFlag)TypeName ¶

typeCategorizableFlag ¶

typeCommand ¶

func (*Command)Args ¶

func (*Command)Bool ¶

func (*Command)Command ¶

func (*Command)Count ¶

func (*Command)Duration ¶

func (*Command)FlagNames ¶

func (*Command)Float ¶

func (*Command)Float32 ¶added inv3.3.0

func (*Command)Float32Arg ¶added inv3.3.0

func (*Command)Float32Args ¶added inv3.3.0

func (*Command)Float32Slice ¶added inv3.3.0

func (*Command)Float64 ¶added inv3.3.0

func (*Command)Float64Arg ¶added inv3.3.0

func (*Command)Float64Args ¶added inv3.3.0

func (*Command)Float64Slice ¶added inv3.3.0

func (*Command)FloatArg ¶added inv3.2.0

func (*Command)FloatArgs ¶added inv3.2.0

func (*Command)FloatSlice ¶

func (*Command)FullName ¶

func (*Command)Generic ¶

func (*Command)HasName ¶

func (*Command)Int ¶

func (*Command)Int16 ¶added inv3.2.0

func (*Command)Int16Arg ¶added inv3.2.0

func (*Command)Int16Args ¶added inv3.2.0