kong – github.com/alecthomas/kong Index | Files | Directories

package kong

import "github.com/alecthomas/kong"

Package kong aims to support arbitrarily complex command-line structures with as little developer effort as possible.

Here's an example: 

shell rm [-f] [-r] <paths> ...
shell ls [<paths> ...]

This can be represented by the following command-line structure: 

package main

import "github.com/alecthomas/kong"

var CLI struct {
  Rm struct {
    Force     bool `short:"f" help:"Force removal."`
    Recursive bool `short:"r" help:"Recursively remove files."`

    Paths []string `arg help:"Paths to remove." type:"path"`
  } `cmd help:"Remove files."`

  Ls struct {
    Paths []string `arg optional help:"Paths to list." type:"path"`
  } `cmd help:"List paths."`
}

func main() {
  kong.Parse(&CLI)
}

See https://github.com/alecthomas/kong for details.

Index

Functions

func ApplyDefaults 

func ApplyDefaults(target any, options ...Option) error

ApplyDefaults if they are not already set.

func DefaultHelpPrinter 

func DefaultHelpPrinter(options HelpOptions, ctx *Context) error

DefaultHelpPrinter is the default HelpPrinter.

func DefaultHelpValueFormatter 

func DefaultHelpValueFormatter(value *Value) string

DefaultHelpValueFormatter is the default HelpValueFormatter.

func DefaultShortHelpPrinter 

func DefaultShortHelpPrinter(options HelpOptions, ctx *Context) error

DefaultShortHelpPrinter is the default HelpPrinter for short help on error.

func ExpandPath 

func ExpandPath(path string) string

ExpandPath is a helper function to expand a relative or home-relative path to an absolute path.

eg. ~/.someconf -> /home/alec/.someconf

func HasInterpolatedVar 

func HasInterpolatedVar(s string, v string) bool

HasInterpolatedVar returns true if the variable "v" is interpolated in "s".

func JoinEscaped 

func JoinEscaped(s []string, sep rune) string

JoinEscaped joins a slice of strings on sep, but also escapes any instances of sep in the fields with \. eg. 

JoinEscaped([]string{"hello,there", "bob"}, ',') == `hello\,there,bob`

func LineIndenter 

func LineIndenter(prefix string) string

LineIndenter adds line points to every new indent.

func SpaceIndenter 

func SpaceIndenter(prefix string) string

SpaceIndenter adds a space indent to the given prefix.

func SplitEscaped 

func SplitEscaped(s string, sep rune) (out []string)

SplitEscaped splits a string on a separator.

It differs from strings.Split() in that the separator can exist in a field by escaping it with a \. eg. 

SplitEscaped(`hello\,there,bob`, ',') == []string{"hello,there", "bob"}

func TreeIndenter 

func TreeIndenter(prefix string) string

TreeIndenter adds line points to every new indent and vertical lines to every layer.

func Visit 

func Visit(node Visitable, visitor Visitor) error

Visit all nodes.

Types

type AfterApply 

type AfterApply interface {
	// This is not the correct signature - see README for details.
	AfterApply(args ...any) error
}

AfterApply is a documentation-only interface describing hooks that run after values are set.

type AfterRun 

type AfterRun interface {
	// This is not the correct signature - see README for details.
	// AfterRun is called after Run() returns.
	AfterRun(args ...any) error
}

AfterRun is a documentation-only interface describing hooks that run after Run() returns.

type Application 

type Application struct {
	*Node
	// Help flag, if the NoDefaultHelp() option is not specified.
	HelpFlag *Flag
}

Application is the root of the Kong model.

type Argument 

type Argument = Node

Argument represents a branching positional argument.

type BeforeApply 

type BeforeApply interface {
	// This is not the correct signature - see README for details.
	BeforeApply(args ...any) error
}

BeforeApply is a documentation-only interface describing hooks that run before values are set.

type BeforeReset 

type BeforeReset interface {
	// This is not the correct signature - see README for details.
	BeforeReset(args ...any) error
}

BeforeReset is a documentation-only interface describing hooks that run before defaults values are applied.

type BeforeResolve 

type BeforeResolve interface {
	// This is not the correct signature - see README for details.
	BeforeResolve(args ...any) error
}

BeforeResolve is a documentation-only interface describing hooks that run before resolvers are applied.

type BoolMapper 

type BoolMapper interface {
	Mapper
	IsBool() bool
}

A BoolMapper is a Mapper to a value that is a boolean.

This is used solely for formatting help.

type BoolMapperExt 

type BoolMapperExt interface {
	Mapper
	IsBoolFromValue(v reflect.Value) bool
}

BoolMapperExt allows a Mapper to dynamically determine if a value is a boolean.

type BoolMapperValue 

type BoolMapperValue interface {
	MapperValue
	IsBool() bool
}

BoolMapperValue may be implemented by fields in order to provide custom mappings for boolean values.

type ChangeDirFlag 

type ChangeDirFlag string

ChangeDirFlag changes the current working directory to a path specified by a flag early in the parsing process, changing how other flags resolve relative paths.

Use this flag to provide a "git -C" like functionality.

It is not compatible with custom named decoders, e.g., existingdir.

func (ChangeDirFlag) Decode 

func (c ChangeDirFlag) Decode(ctx *DecodeContext) error

Decode is used to create a side effect of changing the current working directory.

type Command 

type Command = Node

Command represents a command in the CLI.

type ConfigFlag 

type ConfigFlag string

ConfigFlag uses the configured (via kong.Configuration(loader)) configuration loader to load configuration from a file specified by a flag.

Use this as a flag value to support loading of custom configuration via a flag.

func (ConfigFlag) BeforeResolve 

func (c ConfigFlag) BeforeResolve(kong *Kong, ctx *Context, trace *Path) error

BeforeResolve adds a resolver.

type ConfigurationLoader 

type ConfigurationLoader func(r io.Reader) (Resolver, error)

ConfigurationLoader is a function that builds a resolver from a file.

type Context 

type Context struct {
	*Kong
	// A trace through parsed nodes.
	Path []*Path
	// Original command-line arguments.
	Args []string
	// Error that occurred during trace, if any.
	Error error
	// contains filtered or unexported fields
}

Context contains the current parse context.

func Parse 

func Parse(cli any, options ...Option) *Context

Parse constructs a new parser and parses the default command-line.

func Trace 

func Trace(k *Kong, args []string) (*Context, error)

Trace path of "args" through the grammar tree.

The returned Context will include a Path of all commands, arguments, positionals and flags.

This just constructs a new trace. To fully apply the trace you must call Reset(), Resolve(), Validate() and Apply().

func (*Context) AddResolver 

func (c *Context) AddResolver(resolver Resolver)

AddResolver adds a context-specific resolver.

This is most useful in the BeforeResolve() hook.

func (*Context) Apply 

func (c *Context) Apply() (string, error)

Apply traced context to the target grammar.

func (*Context) ApplyDefaults 

func (c *Context) ApplyDefaults() error

ApplyDefaults if they are not already set.

func (*Context) Bind 

func (c *Context) Bind(args ...any)

Bind adds bindings to the Context.

func (*Context) BindSingletonProvider 

func (c *Context) BindSingletonProvider(provider any) error

BindSingletonProvider allows binding of provider functions. The provider will be called once and the result cached.

"provider" must be a function with the signature func(...) (T, error) or func(...) T, where ... will be recursively injected with bound values.

func (*Context) BindTo 

func (c *Context) BindTo(impl, iface any)

BindTo adds a binding to the Context.

This will typically have to be called like so: 

BindTo(impl, (*MyInterface)(nil))

func (*Context) BindToProvider 

func (c *Context) BindToProvider(provider any) error

BindToProvider allows binding of provider functions.

This is useful when the Run() function of different commands require different values that may not all be initialisable from the main() function.

"provider" must be a function with the signature func(...) (T, error) or func(...) T, where ... will be recursively injected with bound values.

func (*Context) Call 

func (c *Context) Call(fn any, binds ...any) (out []any, err error)

Call an arbitrary function filling arguments with bound values.

func (*Context) Command 

func (c *Context) Command() string

Command returns the full command path.

func (*Context) Empty 

func (c *Context) Empty() bool

Empty returns true if there were no arguments provided.

func (*Context) FlagValue 

func (c *Context) FlagValue(flag *Flag) any

FlagValue returns the set value of a flag if it was encountered and exists, or its default value.

func (*Context) Flags 

func (c *Context) Flags() (flags []*Flag)

Flags returns the accumulated available flags.

func (*Context) PrintUsage 

func (c *Context) PrintUsage(summary bool) error

PrintUsage to Kong's stdout.

If summary is true, a summarised version of the help will be output.

func (*Context) Reset 

func (c *Context) Reset() error

Reset recursively resets values to defaults (as specified in the grammar) or the zero value.

func (*Context) Resolve 

func (c *Context) Resolve() error

Resolve walks through the traced path, applying resolvers to any unset flags.

func (*Context) Run 

func (c *Context) Run(binds ...any) (err error)

Run executes the Run() method on the selected command, which must exist.

Any passed values will be bindable to arguments of the target Run() method. Additionally, all parent nodes in the command structure will be bound.

func (*Context) RunNode 

func (c *Context) RunNode(node *Node, binds ...any) (err error)

RunNode calls the Run() method on an arbitrary node.

This is useful in conjunction with Visit(), for dynamically running commands.

Any passed values will be bindable to arguments of the target Run() method. Additionally, all parent nodes in the command structure will be bound.

func (*Context) Selected 

func (c *Context) Selected() *Node

Selected command or argument.

func (*Context) Validate 

func (c *Context) Validate() error

Validate the current context.

func (*Context) Value 

func (c *Context) Value(path *Path) reflect.Value

Value returns the value for a particular path element.

type DecodeContext 

type DecodeContext struct {
	// Value being decoded into.
	Value *Value
	// Scan contains the input to scan into Target.
	Scan *Scanner
}

DecodeContext is passed to a Mapper's Decode().

It contains the Value being decoded into and the Scanner to parse from.

func (*DecodeContext) WithScanner 

func (r *DecodeContext) WithScanner(scan *Scanner) *DecodeContext

WithScanner creates a clone of this context with a new Scanner.

type ExitCoder 

type ExitCoder interface {
	ExitCode() int
}

ExitCoder is an interface that may be implemented by an error value to provide an integer exit code. The method ExitCode should return an integer that is intended to be used as the exit code for the application.

type FileContentFlag 

type FileContentFlag []byte

FileContentFlag is a flag value that loads a file's contents into its value.

func (*FileContentFlag) Decode 

func (f *FileContentFlag) Decode(ctx *DecodeContext) error

type Flag 

type Flag struct {
	*Value
	Group       *Group // Logical grouping when displaying. May also be used by configuration loaders to group options logically.
	Xor         []string
	And         []string
	PlaceHolder string
	Envs        []string
	Aliases     []string
	Short       rune
	Hidden      bool
	Negated     bool
}

A Flag represents a command-line flag.

func (*Flag) FormatPlaceHolder 

func (f *Flag) FormatPlaceHolder() string

FormatPlaceHolder formats the placeholder string for a Flag.

func (*Flag) String 

func (f *Flag) String() string

type Group 

type Group struct {
	// Key is the `group` field tag value used to identify this group.
	Key string
	// Title is displayed above the grouped items.
	Title string
	// Description is optional and displayed under the Title when non empty.
	// It can be used to introduce the group's purpose to the user.
	Description string
}

Group holds metadata about a command or flag group used when printing help.

type Groups 

type Groups map[string]string

Groups associates `group` field tags with group metadata.

This option is used to simplify Kong tags while providing rich group information such as title and optional description.

Each key in the "groups" map corresponds to the value of a `group` Kong tag, while the first line of the value will be the title, and subsequent lines if any will be the description of the group.

See also ExplicitGroups for a more structured alternative.

func (Groups) Apply 

func (g Groups) Apply(k *Kong) error

type HelpIndenter 

type HelpIndenter func(prefix string) string

HelpIndenter is used to indent new layers in the help tree.

type HelpOptions 

type HelpOptions struct {
	// Don't print top-level usage summary.
	NoAppSummary bool

	// Write a one-line summary of the context.
	Summary bool

	// Write help in a more compact, but still fully-specified, form.
	Compact bool

	// Tree writes command chains in a tree structure instead of listing them separately.
	Tree bool

	// Place the flags after the commands listing.
	FlagsLast bool

	// Indenter modulates the given prefix for the next layer in the tree view.
	// The following exported templates can be used: kong.SpaceIndenter, kong.LineIndenter, kong.TreeIndenter
	// The kong.SpaceIndenter will be used by default.
	Indenter HelpIndenter

	// Don't show the help associated with subcommands
	NoExpandSubcommands bool

	// Clamp the help wrap width to a value smaller than the terminal width.
	// If this is set to a non-positive number, the terminal width is used; otherwise,
	// the min of this value or the terminal width is used.
	WrapUpperBound int
}

HelpOptions for HelpPrinters.

func (HelpOptions) Apply 

func (h HelpOptions) Apply(k *Kong) error

Apply options to Kong as a configuration option.

func (*HelpOptions) CommandTree 

func (h *HelpOptions) CommandTree(node *Node, prefix string) (rows [][2]string)

CommandTree creates a tree with the given node name as root and its children's arguments and sub commands as leaves.

type HelpPrinter 

type HelpPrinter func(options HelpOptions, ctx *Context) error

HelpPrinter is used to print context-sensitive help.

type HelpProvider 

type HelpProvider interface {
	// This string is formatted by go/doc and thus has the same formatting rules.
	Help() string
}

HelpProvider can be implemented by commands/args to provide detailed help.

type HelpValueFormatter 

type HelpValueFormatter func(value *Value) string

HelpValueFormatter is used to format the help text of flags and positional arguments.

type IgnoreDefault 

type IgnoreDefault interface {
	IgnoreDefault()
}

IgnoreDefault can be implemented by flags that want to be applied before any default commands.

type Kong 

type Kong struct {
	// Grammar model.
	Model *Application

	// Termination function (defaults to os.Exit)
	Exit func(int)

	Stdout io.Writer
	Stderr io.Writer
	// contains filtered or unexported fields
}

Kong is the main parser type.

func Must 

func Must(ast any, options ...Option) *Kong

Must creates a new Parser or panics if there is an error.

func New 

func New(grammar any, options ...Option) (*Kong, error)

New creates a new Kong parser on grammar.

See the README (https://github.com/alecthomas/kong) for usage instructions.

func (*Kong) Errorf 

func (k *Kong) Errorf(format string, args ...any) *Kong

Errorf writes a message to Kong.Stderr with the application name prefixed.

func (*Kong) FatalIfErrorf 

func (k *Kong) FatalIfErrorf(err error, args ...any)

FatalIfErrorf terminates with an error message if err != nil. If the error implements the ExitCoder interface, the ExitCode() method is called and the application exits with that status. Otherwise, the application exits with status 1.

func (*Kong) Fatalf 

func (k *Kong) Fatalf(format string, args ...any)

Fatalf writes a message to Kong.Stderr with the application name prefixed then exits with status 1.

func (*Kong) LoadConfig 

func (k *Kong) LoadConfig(path string) (Resolver, error)

LoadConfig from path using the loader configured via Configuration(loader).

"path" will have ~ and any variables expanded.

func (*Kong) Parse 

func (k *Kong) Parse(args []string) (ctx *Context, err error)

Parse arguments into target.

The return Context can be used to further inspect the parsed command-line, to format help, to find the selected command, to run command Run() methods, and so on. See Context and README for more information.

Will return a ParseError if a *semantically* invalid command-line is encountered (as opposed to a syntactically invalid one, which will report a normal error).

func (*Kong) Printf 

func (k *Kong) Printf(format string, args ...any) *Kong

Printf writes a message to Kong.Stdout with the application name prefixed.

type Mapper 

type Mapper interface {
	// Decode ctx.Value with ctx.Scanner into target.
	Decode(ctx *DecodeContext, target reflect.Value) error
}

A Mapper represents how a field is mapped from command-line values to Go.

Mappers can be associated with concrete fields via pointer, reflect.Type, reflect.Kind, or via a "type" tag.

Additionally, if a type implements the MapperValue interface, it will be used.

type MapperFunc 

type MapperFunc func(ctx *DecodeContext, target reflect.Value) error

A MapperFunc is a single function that complies with the Mapper interface.

func (MapperFunc) Decode 

func (m MapperFunc) Decode(ctx *DecodeContext, target reflect.Value) error

type MapperValue 

type MapperValue interface {
	Decode(ctx *DecodeContext) error
}

MapperValue may be implemented by fields in order to provide custom mapping. Mappers may additionally implement PlaceHolderProvider to provide custom placeholder text.

type NamedFileContentFlag 

type NamedFileContentFlag struct {
	Filename string
	Contents []byte
}

NamedFileContentFlag is a flag value that loads a file's contents and filename into its value.

func (*NamedFileContentFlag) Decode 

func (f *NamedFileContentFlag) Decode(ctx *DecodeContext) error

type Next 

type Next func(err error) error

Next should be called by Visitor to proceed with the walk.

The walk will terminate if "err" is non-nil.

type Node 

type Node struct {
	Type        NodeType
	Parent      *Node
	Name        string
	Help        string // Short help displayed in summaries.
	Detail      string // Detailed help displayed when describing command/arg alone.
	Group       *Group
	Hidden      bool
	Flags       []*Flag
	Positional  []*Positional
	Children    []*Node
	DefaultCmd  *Node
	Target      reflect.Value // Pointer to the value in the grammar that this Node is associated with.
	Tag         *Tag
	Aliases     []string
	Passthrough bool // Set to true to stop flag parsing when encountered.
	Active      bool // Denotes the node is part of an active branch in the CLI.

	Argument *Value // Populated when Type is ArgumentNode.
}

Node is a branch in the CLI. ie. a command or positional argument.

func (*Node) AllFlags 

func (n *Node) AllFlags(hide bool) (out [][]*Flag)

AllFlags returns flags from all ancestor branches encountered.

If "hide" is true hidden flags will be omitted.

func (*Node) ClosestGroup 

func (n *Node) ClosestGroup() *Group

ClosestGroup finds the first non-nil group in this node and its ancestors.

func (*Node) Depth 

func (n *Node) Depth() int

Depth of the command from the application root.

func (*Node) Find 

func (n *Node) Find(ptr any) *Node

Find a command/argument/flag by pointer to its field.

Returns nil if not found. Panics if ptr is not a pointer.

func (*Node) FlagSummary 

func (n *Node) FlagSummary(hide bool) string

FlagSummary for the node.

func (*Node) FullPath 

func (n *Node) FullPath() string

FullPath is like Path() but includes the Application root node.

func (*Node) Leaf 

func (n *Node) Leaf() bool

Leaf returns true if this Node is a leaf node.

func (*Node) Leaves 

func (n *Node) Leaves(hide bool) (out []*Node)

Leaves returns the leaf commands/arguments under Node.

If "hidden" is true hidden leaves will be omitted.

func (*Node) Path 

func (n *Node) Path() (out string)

Path through ancestors to this Node.

func (*Node) Summary 

func (n *Node) Summary() string

Summary help string for the node (not including application name).

func (*Node) Vars 

func (n *Node) Vars() Vars

Vars returns the combined Vars defined by all ancestors of this Node.

type NodeType 

type NodeType int

NodeType is an enum representing the type of a Node. 

const (
	ApplicationNode NodeType = iota
	CommandNode
	ArgumentNode
)

Node type enumerations.

type Option 

type Option interface {
	Apply(k *Kong) error
}

An Option applies optional changes to the Kong application.

func AutoGroup 

func AutoGroup(format func(parent Visitable, flag *Flag) *Group) Option

AutoGroup automatically assigns groups to flags.

func Bind 

func Bind(args ...any) Option

Bind binds values for hooks and Run() function arguments.

Any arguments passed will be available to the receiving hook functions, but may be omitted. Additionally, *Kong and the current *Context will also be made available.

There are two hook points: 

		BeforeApply(...) error
  	AfterApply(...) error

Called before validation/assignment, and immediately after validation/assignment, respectively.

func BindSingletonProvider 

func BindSingletonProvider(provider any) Option

BindSingletonProvider binds an injected value to a provider function. The provider function must have the signature: 

func(...) (T, error)
func(...) T

Unlike BindToProvider, the provider function will only be called at most once, and the result will be cached and reused across multiple recipients of the injected value.

func BindTo 

func BindTo(impl, iface any) Option

BindTo allows binding of implementations to interfaces. 

BindTo(impl, (*iface)(nil))

func BindToProvider 

func BindToProvider(provider any) Option

BindToProvider binds an injected value to a provider function.

The provider function must have one of the following signatures: 

func(...) (T, error)
func(...) T

Where arguments to the function are injected by Kong.

This is useful when the Run() function of different commands require different values that may not all be initialisable from the main() function.

func ClearResolvers 

func ClearResolvers() Option

ClearResolvers clears all existing resolvers.

func Configuration 

func Configuration(loader ConfigurationLoader, paths ...string) Option

Configuration provides Kong with support for loading defaults from a set of configuration files.

Paths will be opened in order, and "loader" will be used to provide a Resolver which is registered with Kong.

Note: The JSON function is a ConfigurationLoader.

~ and variable expansion will occur on the provided paths.

func ConfigureHelp 

func ConfigureHelp(options HelpOptions) Option

ConfigureHelp sets the HelpOptions to use for printing help.

func DefaultEnvars 

func DefaultEnvars(prefix string) Option

DefaultEnvars option inits environment names for flags. The name will not generate if tag "env" is "-". Predefined environment variables are skipped.

For example: 

--some.value -> PREFIX_SOME_VALUE

func Description 

func Description(description string) Option

Description sets the application description.

func DynamicCommand 

func DynamicCommand(name, help, group string, cmd any, tags ...string) Option

DynamicCommand registers a dynamically constructed command with the root of the CLI.

This is useful for command-line structures that are extensible via user-provided plugins.

"tags" is a list of extra tag strings to parse, in the form <key>:"<value>".

func Embed 

func Embed(strct any, tags ...string) Option

Embed a struct into the root of the CLI.

"strct" must be a pointer to a structure.

func Exit 

func Exit(exit func(int)) Option

Exit overrides the function used to terminate. This is useful for testing or interactive use.

func ExplicitGroups 

func ExplicitGroups(groups []Group) Option

ExplicitGroups associates `group` field tags with their metadata.

It can be used to provide a title or header to a command or flag group.

func FlagNamer 

func FlagNamer(namer func(fieldName string) string) Option

FlagNamer allows you to override the default kebab-case automated flag name generation.

func Help 

func Help(help HelpPrinter) Option

Help printer to use.

func HelpFormatter 

func HelpFormatter(helpFormatter HelpValueFormatter) Option

HelpFormatter configures how the help text is formatted.

Deprecated: Use ValueFormatter() instead.

func IgnoreFields 

func IgnoreFields(regexes ...string) Option

IgnoreFields will cause kong.New() to skip field names that match any of the provided regex patterns. This is useful if you are not able to add a kong="-" struct tag to a struct/element before the call to New.

Example: When referencing protoc generated structs, you will likely want to ignore/skip XXX_* fields.

func KindMapper 

func KindMapper(kind reflect.Kind, mapper Mapper) Option

KindMapper registers a mapper to a kind.

func Name 

func Name(name string) Option

Name overrides the application name.

func NamedMapper 

func NamedMapper(name string, mapper Mapper) Option

NamedMapper registers a mapper to a name.

func NoDefaultHelp 

func NoDefaultHelp() Option

NoDefaultHelp disables the default help flags.

func PostBuild 

func PostBuild(fn func(*Kong) error) Option

PostBuild provides read/write access to kong.Kong after initial construction of the model is complete but before parsing occurs.

This is useful for, e.g., adding short options to flags, updating help, etc.

func Resolvers 

func Resolvers(resolvers ...Resolver) Option

Resolvers registers flag resolvers.

func ShortHelp 

func ShortHelp(shortHelp HelpPrinter) Option

ShortHelp configures the short usage message.

It should be used together with kong.ShortUsageOnError() to display a custom short usage message on errors.

func ShortUsageOnError 

func ShortUsageOnError() Option

ShortUsageOnError configures Kong to display context-sensitive short usage if FatalIfErrorf is called with an error. The default short usage message can be overridden with kong.ShortHelp(...).

func TypeMapper 

func TypeMapper(typ reflect.Type, mapper Mapper) Option

TypeMapper registers a mapper to a type.

func UsageOnError 

func UsageOnError() Option

UsageOnError configures Kong to display context-sensitive usage if FatalIfErrorf is called with an error.

func ValueFormatter 

func ValueFormatter(helpFormatter HelpValueFormatter) Option

ValueFormatter configures how the help text is formatted.

func ValueMapper 

func ValueMapper(ptr any, mapper Mapper) Option

ValueMapper registers a mapper to a field value.

func WithAfterApply 

func WithAfterApply(fn any) Option

WithAfterApply registers a hook to run after values are applied to the grammar and validated.

func WithBeforeApply 

func WithBeforeApply(fn any) Option

WithBeforeApply registers a hook to run before command line arguments are applied to the grammar.

func WithBeforeReset 

func WithBeforeReset(fn any) Option

WithBeforeReset registers a hook to run before fields values are reset to their defaults (as specified in the grammar) or to zero values.

func WithBeforeResolve 

func WithBeforeResolve(fn any) Option

WithBeforeResolve registers a hook to run before resolvers are applied.

func Writers 

func Writers(stdout, stderr io.Writer) Option

Writers overrides the default writers. Useful for testing or interactive use.

type OptionFunc 

type OptionFunc func(k *Kong) error

OptionFunc is function that adheres to the Option interface.

func (OptionFunc) Apply 

func (o OptionFunc) Apply(k *Kong) error

type ParseError 

type ParseError struct {
	Context *Context
	// contains filtered or unexported fields
}

ParseError is the error type returned by Kong.Parse().

It contains the parse Context that triggered the error.

func (*ParseError) ExitCode 

func (p *ParseError) ExitCode() int

ExitCode returns the status that Kong should exit with if it fails with a ParseError.

func (*ParseError) Unwrap 

func (p *ParseError) Unwrap() error

Unwrap returns the original cause of the error.

type PassthroughMode 

type PassthroughMode int

PassthroughMode indicates how parameters are passed through when "passthrough" is set. 

const (
	// PassThroughModeNone indicates passthrough mode is disabled.
	PassThroughModeNone PassthroughMode = iota
	// PassThroughModeAll indicates that all parameters, including flags, are passed through. It is the default.
	PassThroughModeAll
	// PassThroughModePartial will validate flags until the first positional argument is encountered, then pass through all remaining positional arguments.
	PassThroughModePartial
)

type Path 

type Path struct {
	Parent *Node

	// One of these will be non-nil.
	App        *Application
	Positional *Positional
	Flag       *Flag
	Argument   *Argument
	Command    *Command

	// Flags added by this node.
	Flags []*Flag

	// True if this Path element was created as the result of a resolver.
	Resolved bool
	// contains filtered or unexported fields
}

Path records the nodes and parsed values from the current command-line.

func (*Path) Node 

func (p *Path) Node() *Node

Node returns the Node associated with this Path, or nil if Path is a non-Node.

func (*Path) Remainder 

func (p *Path) Remainder() []string

Remainder returns the remaining unparsed args after this Path element.

func (*Path) Visitable 

func (p *Path) Visitable() Visitable

Visitable returns the Visitable for this path element.

type PlaceHolderProvider 

type PlaceHolderProvider interface {
	PlaceHolder(flag *Flag) string
}

PlaceHolderProvider can be implemented by mappers to provide custom placeholder text.

type Plugins 

type Plugins []any

Plugins are dynamically embedded command-line structures.

Each element in the Plugins list *must* be a pointer to a structure.

type Positional 

type Positional = Value

A Positional represents a non-branching command-line positional argument.

type Registry 

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

A Registry contains a set of mappers and supporting lookup methods.

func NewRegistry 

func NewRegistry() *Registry

NewRegistry creates a new (empty) Registry.

func (*Registry) ForNamedType 

func (r *Registry) ForNamedType(name string, typ reflect.Type) Mapper

ForNamedType finds a mapper for a type with a user-specified name.

Will return nil if a mapper can not be determined.

func (*Registry) ForNamedValue 

func (r *Registry) ForNamedValue(name string, value reflect.Value) Mapper

ForNamedValue finds a mapper for a value with a user-specified name.

Will return nil if a mapper can not be determined.

func (*Registry) ForType 

func (r *Registry) ForType(typ reflect.Type) Mapper

ForType finds a mapper from a type, by type, then kind.

Will return nil if a mapper can not be determined.

func (*Registry) ForValue 

func (r *Registry) ForValue(value reflect.Value) Mapper

ForValue looks up the Mapper for a reflect.Value.

func (*Registry) RegisterDefaults 

func (r *Registry) RegisterDefaults() *Registry

RegisterDefaults registers Mappers for all builtin supported Go types and some common stdlib types.

func (*Registry) RegisterKind 

func (r *Registry) RegisterKind(kind reflect.Kind, mapper Mapper) *Registry

RegisterKind registers a Mapper for a reflect.Kind.

func (*Registry) RegisterName 

func (r *Registry) RegisterName(name string, mapper Mapper) *Registry

RegisterName registers a mapper to be used if the value mapper has a "type" tag matching name.

eg. 

		Mapper string `kong:"type='colour'`
  	registry.RegisterName("colour", ...)

func (*Registry) RegisterType 

func (r *Registry) RegisterType(typ reflect.Type, mapper Mapper) *Registry

RegisterType registers a Mapper for a reflect.Type.

func (*Registry) RegisterValue 

func (r *Registry) RegisterValue(ptr any, mapper Mapper) *Registry

RegisterValue registers a Mapper by pointer to the field value.

type Resolver 

type Resolver interface {
	// Validate configuration against Application.
	//
	// This can be used to validate that all provided configuration is valid within  this application.
	Validate(app *Application) error

	// Resolve the value for a Flag.
	Resolve(context *Context, parent *Path, flag *Flag) (any, error)
}

A Resolver resolves a Flag value from an external source.

func JSON 

func JSON(r io.Reader) (Resolver, error)

JSON returns a Resolver that retrieves values from a JSON source.

Flag names are used as JSON keys indirectly, by tring snake_case and camelCase variants.

type ResolverFunc 

type ResolverFunc func(context *Context, parent *Path, flag *Flag) (any, error)

ResolverFunc is a convenience type for non-validating Resolvers.

func (ResolverFunc) Resolve 

func (r ResolverFunc) Resolve(context *Context, parent *Path, flag *Flag) (any, error)

func (ResolverFunc) Validate 

func (r ResolverFunc) Validate(app *Application) error

type Scanner 

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

Scanner is a stack-based scanner over command-line tokens.

Initially all tokens are untyped. As the parser consumes tokens it assigns types, splits tokens, and pushes them back onto the stream.

For example, the token "--foo=bar" will be split into the following by the parser: 

[{FlagToken, "foo"}, {FlagValueToken, "bar"}]

func Scan 

func Scan(args ...string) *Scanner

Scan creates a new Scanner from args with untyped tokens.

func ScanAsType 

func ScanAsType(ttype TokenType, args ...string) *Scanner

ScanAsType creates a new Scanner from args with the given type.

func ScanFromTokens 

func ScanFromTokens(tokens ...Token) *Scanner

ScanFromTokens creates a new Scanner from a slice of tokens.

func (*Scanner) Len 

func (s *Scanner) Len() int

Len returns the number of input arguments.

func (*Scanner) Peek 

func (s *Scanner) Peek() Token

Peek at the next Token or return an EOLToken.

func (*Scanner) PeekAll 

func (s *Scanner) PeekAll() []Token

PeekAll remaining tokens

func (*Scanner) Pop 

func (s *Scanner) Pop() Token

Pop the front token off the Scanner.

func (*Scanner) PopUntil 

func (s *Scanner) PopUntil(predicate func(Token) bool) (values []Token)

PopUntil predicate returns true.

func (*Scanner) PopValue 

func (s *Scanner) PopValue(context string) (Token, error)

PopValue pops a value token, or returns an error.

"context" is used to assist the user if the value can not be popped, eg. "expected <context> value but got <type>"

func (*Scanner) PopValueInto 

func (s *Scanner) PopValueInto(context string, target any) error

PopValueInto pops a value token into target or returns an error.

"context" is used to assist the user if the value can not be popped, eg. "expected <context> value but got <type>"

func (*Scanner) PopWhile 

func (s *Scanner) PopWhile(predicate func(Token) bool) (values []Token)

PopWhile predicate returns true.

func (*Scanner) Push 

func (s *Scanner) Push(arg any) *Scanner

Push an untyped Token onto the front of the Scanner.

func (*Scanner) PushToken 

func (s *Scanner) PushToken(token Token) *Scanner

PushToken pushes a preconstructed Token onto the front of the Scanner.

func (*Scanner) PushTyped 

func (s *Scanner) PushTyped(arg any, typ TokenType) *Scanner

PushTyped pushes a typed token onto the front of the Scanner.

type Tag 

type Tag struct {
	Ignored         bool // Field is ignored by Kong. ie. kong:"-"
	Cmd             bool
	Arg             bool
	Required        bool
	Optional        bool
	Name            string
	Help            string
	Type            string
	TypeName        string
	HasDefault      bool
	Default         string
	Format          string
	PlaceHolder     string
	Envs            []string
	Short           rune
	Hidden          bool
	Sep             rune
	MapSep          rune
	Enum            string
	Group           string
	Xor             []string
	And             []string
	Vars            Vars
	Prefix          string // Optional prefix on anonymous structs. All sub-flags will have this prefix.
	EnvPrefix       string
	XorPrefix       string // Optional prefix on XOR/AND groups.
	Embed           bool
	Aliases         []string
	Negatable       string
	Passthrough     bool // Deprecated: use PassthroughMode instead.
	PassthroughMode PassthroughMode
	// contains filtered or unexported fields
}

Tag represents the parsed state of Kong tags in a struct field tag.

func (*Tag) Get 

func (t *Tag) Get(k string) string

Get returns the value of the given tag.

Note that this will return the empty string if the tag is missing.

func (*Tag) GetAll 

func (t *Tag) GetAll(k string) []string

GetAll returns all encountered values for a tag, in the case of multiple occurrences.

func (*Tag) GetBool 

func (t *Tag) GetBool(k string) (bool, error)

GetBool returns true if the given tag looks like a boolean truth string.

func (*Tag) GetFloat 

func (t *Tag) GetFloat(k string) (float64, error)

GetFloat parses the given tag as a float64.

func (*Tag) GetInt 

func (t *Tag) GetInt(k string) (int64, error)

GetInt parses the given tag as an int64.

func (*Tag) GetRune 

func (t *Tag) GetRune(k string) (rune, error)

GetRune parses the given tag as a rune.

func (*Tag) GetSep 

func (t *Tag) GetSep(k string, dflt rune) (rune, error)

GetSep parses the given tag as a rune separator, allowing for a default or none. The separator is returned, or -1 if "none" is specified. If the tag value is an invalid utf8 sequence, the default rune is returned as well as an error. If the tag value is more than one rune, the first rune is returned as well as an error.

func (*Tag) Has 

func (t *Tag) Has(k string) bool

Has returns true if the tag contained the given key.

func (*Tag) String 

func (t *Tag) String() string

type Token 

type Token struct {
	Value any
	Type  TokenType
}

Token created by Scanner.

func (Token) InferredType 

func (t Token) InferredType() TokenType

InferredType tries to infer the type of a token.

func (Token) IsEOL 

func (t Token) IsEOL() bool

IsEOL returns true if this Token is past the end of the line.

func (Token) IsValue 

func (t Token) IsValue() bool

IsValue returns true if token is usable as a parseable value.

A parseable value is either a value typed token, or an untyped token NOT starting with a hyphen.

func (Token) String 

func (t Token) String() string

type TokenType 

type TokenType int

TokenType is the type of a token. 

const (
	UntypedToken TokenType = iota
	EOLToken
	FlagToken               // --<flag>
	FlagValueToken          // =<value>
	ShortFlagToken          // -<short>[<tail]
	ShortFlagTailToken      // <tail>
	PositionalArgumentToken // <arg>
)

Token types.

func (TokenType) IsAny 

func (t TokenType) IsAny(types ...TokenType) bool

IsAny returns true if the token's type is any of those provided.

func (TokenType) String 

func (t TokenType) String() string

type Value 

type Value struct {
	Flag            *Flag // Nil if positional argument.
	Name            string
	Help            string
	OrigHelp        string // Original help string, without interpolated variables.
	HasDefault      bool
	Default         string
	DefaultValue    reflect.Value
	Enum            string
	Mapper          Mapper
	Tag             *Tag
	Target          reflect.Value
	Required        bool
	Set             bool            // Set to true when this value is set through some mechanism.
	Format          string          // Formatting directive, if applicable.
	Position        int             // Position (for positional arguments).
	Passthrough     bool            // Deprecated: Use PassthroughMode instead. Set to true to stop flag parsing when encountered.
	PassthroughMode PassthroughMode //
	Active          bool            // Denotes the value is part of an active branch in the CLI.
}

A Value is either a flag or a variable positional argument.

func (*Value) Apply 

func (v *Value) Apply(value reflect.Value)

Apply value to field.

func (*Value) ApplyDefault 

func (v *Value) ApplyDefault() error

ApplyDefault value to field if it is not already set.

func (*Value) EnumMap 

func (v *Value) EnumMap() map[string]bool

EnumMap returns a map of the enums in this value.

func (*Value) EnumSlice 

func (v *Value) EnumSlice() []string

EnumSlice returns a slice of the enums in this value.

func (*Value) IsBool 

func (v *Value) IsBool() bool

IsBool returns true if the underlying value is a boolean.

func (*Value) IsCounter 

func (v *Value) IsCounter() bool

IsCounter returns true if the value is a counter.

func (*Value) IsCumulative 

func (v *Value) IsCumulative() bool

IsCumulative returns true if the type can be accumulated into.

func (*Value) IsMap 

func (v *Value) IsMap() bool

IsMap returns true if the value is a map.

func (*Value) IsSlice 

func (v *Value) IsSlice() bool

IsSlice returns true if the value is a slice.

func (*Value) Parse 

func (v *Value) Parse(scan *Scanner, target reflect.Value) (err error)

Parse tokens into value, parse, and validate, but do not write to the field.

func (*Value) Reset 

func (v *Value) Reset() error

Reset this value to its default, either the zero value or the parsed result of its envar, or its "default" tag.

Does not include resolvers.

func (*Value) ShortSummary 

func (v *Value) ShortSummary() string

ShortSummary returns a human-readable summary of the value, not including any placeholders/defaults.

func (*Value) Summary 

func (v *Value) Summary() string

Summary returns a human-readable summary of the value.

type Vars 

type Vars map[string]string

Vars sets the variables to use for interpolation into help strings and default values.

See README for details.

func (Vars) Apply 

func (v Vars) Apply(k *Kong) error

Apply lets Vars act as an Option.

func (Vars) CloneWith 

func (v Vars) CloneWith(vars Vars) Vars

CloneWith clones the current Vars and merges "vars" onto the clone.

type VarsContributor 

type VarsContributor interface {
	Vars(ctx *Value) Vars
}

VarsContributor can be implemented by a Mapper to contribute Vars during interpolation.

type VersionFlag 

type VersionFlag bool

VersionFlag is a flag type that can be used to display a version number, stored in the "version" variable.

func (VersionFlag) BeforeReset 

func (v VersionFlag) BeforeReset(app *Kong, vars Vars) error

BeforeReset writes the version variable and terminates with a 0 exit status.

type Visitable 

type Visitable interface {
	// contains filtered or unexported methods
}

A Visitable component in the model.

type Visitor 

type Visitor func(node Visitable, next Next) error

Visitor can be used to walk all nodes in the model.

Source Files

build.go callbacks.go camelcase.go context.go defaults.go doc.go error.go exit.go global.go guesswidth.go help.go hooks.go interpolate.go kong.go levenshtein.go mapper.go model.go negatable.go options.go resolver.go scanner.go tag.go util.go visit.go

Directories

PathSynopsis
_examples
_examples/dockernolint
_examples/shell
_examples/shell/commandstring
_examples/shell/help
Version
v1.10.0 (latest)
Published
Mar 22, 2025
Platform
js/wasm
Imports
21 packages
Last checked
now –

Tools for package owners.