kong

package module
v0.1.17 Latest Latest
Warning

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

 Go to latest Published: Jun 21, 2019 License: MIT Imports: 22 Imported by: 2,080

README

Kong is a command-line parser for Go CircleCI

  1. Introduction
  2. Help
  3. Command handling
    1. Switch on the command string
    2. Attach a Run(...) error method to each command
  4. Hooks: BeforeResolve(), BeforeApply(), AfterApply() and the Bind() option
  5. Flags
  6. Commands and sub-commands
  7. Branching positional arguments
  8. Terminating positional arguments
  9. Slices
  10. Maps
  11. Custom named decoders
  12. Custom decoders (mappers)
  13. Supported tags
  14. Variable interpolation
  15. Modifying Kong's behaviour
    1. Name(help) and Description(help) - set the application name description
    2. Configuration(loader, paths...) - load defaults from configuration files
    3. Resolver(...) - support for default values from external sources
    4. *Mapper(...) - customising how the command-line is mapped to Go values
    5. ConfigureHelp(HelpOptions) and Help(HelpFunc) - customising help
    6. Bind(...) - bind values for callback hooks and Run() methods
    7. Other options

Introduction

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

To achieve that, command-lines are expressed as Go types, with the structure and tags directing how the command line is mapped onto the struct.

For example, the following command-line:

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

Can be represented by the following command-line structure:

package main

import "github.com/alecthomas/kong"

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

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

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

func main() {
  ctx := kong.Parse(&CLI)
  switch ctx.Command() {
  case "rm <path>":
  case "ls":
  default:
    panic(ctx.Command())
  }
}

Help

Help is automatically generated. With no other arguments provided, help will display a full summary of all available commands.

eg.

$ shell --help
usage: shell <command>

A shell-like example app.

Flags:
  --help   Show context-sensitive help.
  --debug  Debug mode.

Commands:
  rm <path> ...
    Remove files.

  ls [<path> ...]
    List paths.

If a command is provided, the help will show full detail on the command including all available flags.

eg.

$ shell --help rm
usage: shell rm <paths> ...

Remove files.

Arguments:
  <paths> ...  Paths to remove.

Flags:
      --debug        Debug mode.

  -f, --force        Force removal.
  -r, --recursive    Recursively remove files.

Command handling

There are two ways to handle commands in Kong.

Switch on the command string

When you call kong.Parse() it will return a unique string representation of the command. Each command branch in the hierarchy will be a bare word and each branching argument or required positional argument will be the name surrounded by angle brackets. Here's an example:

There's an example of this pattern here.

eg.

package main

import "github.com/alecthomas/kong"

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

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

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

func main() {
  ctx := kong.Parse(&CLI)
  switch ctx.Command() {
  case "rm <path>":
  case "ls":
  default:
    panic(ctx.Command())
  }
}

This has the advantage that it is convenient, but the downside that if you modify your CLI structure, the strings may change. This can be fragile.

Attach a Run(...) error method to each command

A more robust approach is to break each command out into their own structs:

  1. Break leaf commands out into separate structs.
  2. Attach a Run(...) error method to all leaf commands.
  3. Call kong.Kong.Parse() to obtain a kong.Context.
  4. Call kong.Context.Run(bindings...) to call the selected parsed command.

Once a command node is selected by Kong it will search from that node back to the root. Each encountered command node with a Run(...) error will be called in reverse order. This allows sub-trees to be re-used fairly conveniently.

In addition to values bound with the kong.Bind(...) option, any values passed through to kong.Context.Run(...) are also bindable to the target's Run() arguments.

Finally, hooks can also contribute bindings via kong.Context.Bind() and kong.Context.BindTo().

There's a full example emulating part of the Docker CLI here.

eg.

type RmCmd struct {
  Force     bool `help:"Force removal."`
  Recursive bool `help:"Recursively remove files."`

  Paths []string `arg name:"path" help:"Paths to remove." type:"path"`
}

func (r *RmCmd) Run(debug bool) error {
  fmt.Println("rm", r.Paths)
  return nil
}

type LsCmd struct {
  Paths []string `arg optional name:"path" help:"Paths to list." type:"path"`
}

func (l *LsCmd) Run(debug bool) error {
  fmt.Println("ls", l.Paths)
  return nil
}

var cli struct {
  Debug bool `help:"Enable debug mode."`

  Rm RmCmd `cmd help:"Remove files."`
  Ls LsCmd `cmd help:"List paths."`
}

func main() {
  ctx := kong.Parse(&cli)
  // Call the Run() method of the selected parsed command.
  err = ctx.Run(cli.Debug)
  ctx.FatalIfErrorf(err)
}

Hooks: BeforeResolve(), BeforeApply(), AfterApply() and the Bind() option

If a node in the grammar has a BeforeResolve(...), BeforeApply(...) error and/or AfterApply(...) error method, those methods will be called before validation/assignment and after validation/assignment, respectively.

The --help flag is implemented with a BeforeApply hook.

Arguments to hooks are provided via the Bind(...) option. *Kong, *Context and *Path are also bound and finally, hooks can also contribute bindings via kong.Context.Bind() and kong.Context.BindTo().

eg.

// A flag with a hook that, if triggered, will set the debug loggers output to stdout.
var debugFlag bool

func (d debugFlag) BeforeApply(logger *log.Logger) error {
  logger.SetOutput(os.Stdout)
  return nil
}

var cli struct {
  Debug debugFlag `help:"Enable debug logging."`
}

func main() {
  // Debug logger going to discard.
  logger := log.New(ioutil.Discard, "", log.LstdFlags)

  ctx := kong.Parse(&cli, kong.Bind(logger))

  // ...
}

Flags

Any mapped field in the command structure not tagged with cmd or arg will be a flag. Flags are optional by default.

eg. The command-line app [--flag="foo"] can be represented by the following.

type CLI struct {
  Flag string
}

Commands and sub-commands

Sub-commands are specified by tagging a struct field with cmd. Kong supports arbitrarily nested commands.

eg. The following struct represents the CLI structure command [--flag="str"] sub-command.

type CLI struct {
  Command struct {
    Flag string

    SubCommand struct {
    } `cmd`
  } `cmd`
}

Branching positional arguments

In addition to sub-commands, structs can also be configured as branching positional arguments.

This is achieved by tagging an unmapped nested struct field with arg, then including a positional argument field inside that struct with the same name. For example, the following command structure:

app rename <name> to <name>

Can be represented with the following:

var CLI struct {
  Rename struct {
    Name struct {
      Name string `arg` // <-- NOTE: identical name to enclosing struct field.
      To struct {
        Name struct {
          Name string `arg`
        } `arg`
      } `cmd`
    } `arg`
  } `cmd`
}

This looks a little verbose in this contrived example, but typically this will not be the case.

Terminating positional arguments

If a mapped type is tagged with arg it will be treated as the final positional values to be parsed on the command line.

If a positional argument is a slice, all remaining arguments will be appended to that slice.

Slices

Slice values are treated specially. First the input is split on the sep:"<rune>" tag (defaults to ,), then each element is parsed by the slice element type and appended to the slice. If the same value is encountered multiple times, elements continue to be appended.

To represent the following command-line:

cmd ls <file> <file> ...

You would use the following:

var CLI struct {
  Ls struct {
    Files []string `arg type:"existingfile"`
  } `cmd`
}

Maps

Maps are similar to slices except that only one key/value pair can be assigned per value, and the sep tag denotes the assignment character and defaults to =.

To represent the following command-line:

cmd config set <key>=<value> <key>=<value> ...

You would use the following:

var CLI struct {
  Config struct {
    Set struct {
      Config map[string]float64 `arg type:"file:"`
    } `cmd`
  } `cmd`
}

For flags, multiple key+value pairs should be separated by ; eg. --set="key1=value1;key2=value2".

Custom named decoders

Kong includes a number of builtin custom type mappers. These can be used by specifying the tag type:"<type>". They are registered with the option function NamedMapper(name, mapper).

Name Description
path A path. ~ expansion is applied.
existingfile An existing file. ~ expansion is applied.
existingdir An existing directory. ~ expansion is applied.

Slices and maps treat type tags specially. For slices, the type:"" tag specifies the element type. For maps, the tag has the format tag:"[<key>]:[<value>]" where either may be omitted.

Custom decoders (mappers)

If a field implements the MapperValue interface it will be used to decode arguments into the field.

Supported tags

Tags can be in two forms:

  1. Standard Go syntax, eg. kong:"required,name='foo'".
  2. Bare tags, eg. required name:"foo"

Both can coexist with standard Tag parsing.

Tag Description
cmd If present, struct is a command.
arg If present, field is an argument.
env:"X" Specify envar to use for default value.
name:"X" Long name, for overriding field name.
help:"X" Help text.
type:"X" Specify named types to use.
placeholder:"X" Placeholder text.
default:"X" Default value.
short:"X" Short name, if flag.
required If present, flag/arg is required.
optional If present, flag/arg is optional.
hidden If present, command or flag is hidden.
format:"X" Format for parsing input, if supported.
sep:"X" Separator for sequences (defaults to ","). May be none to disable splitting.
enum:"X,Y,..." Set of valid values allowed for this flag.
group:"X" Logical group for a flag or command.
prefix:"X" Prefix for all sub-flags.
set:"K=V" Set a variable for expansion by child elements. Multiples can occur.
embed If present, this field's children will be embedded in the parent. Useful for composition.

Variable interpolation

Kong supports limited variable interpolation into help strings, enum lists and default values.

Variables are in the form:

${<name>}

Variables are set with the Vars{"key": "value", ...} option. Undefined variable references in the grammar will result in an error at construction time.

Variables can also be set via the set:"K=V" tag. In this case, those variables will be available for that node and all children. This is useful for composition by allowing the same struct to be reused.

When interpolating into flag or argument help strings, some extra variables are defined from the value itself:

${default}
${enum}

eg.

type cli struct {
  Config string `type:"path" default:"${config_file}"`
}

func main() {
  kong.Parse(&cli,
    kong.Vars{
      "config_file": "~/.app.conf",
    })
}

Modifying Kong's behaviour

Each Kong parser can be configured via functional options passed to New(cli interface{}, options...Option).

The full set of options can be found here.

Name(help) and Description(help) - set the application name description

Set the application name and/or description.

The name of the application will default to the binary name, but can be overridden with Name(name).

As with all help in Kong, text will be wrapped to the terminal.

Configuration(loader, paths...) - load defaults from configuration files

This option provides Kong with support for loading defaults from a set of configuration files. Each file is opened, if possible, and the loader called to create a resolver for that file.

eg.

kong.Parse(&cli, kong.Configuration(kong.JSON, "/etc/myapp.json", "~/.myapp.json"))
Resolver(...) - support for default values from external sources

Resolvers are Kong's extension point for providing default values from external sources. As an example, support for environment variables via the env tag is provided by a resolver. There's also a builtin resolver for JSON configuration files.

Example resolvers can be found in resolver.go.

*Mapper(...) - customising how the command-line is mapped to Go values

Command-line arguments are mapped to Go values via the Mapper interface:

// A Mapper knows how to map command-line input to Go.
type Mapper interface {
  // Decode scan into target.
  //
  // "ctx" contains context about the value being decoded that may be useful
  // to some mapperss.
  Decode(ctx *MapperContext, scan *Scanner, target reflect.Value) error
}

All builtin Go types (as well as a bunch of useful stdlib types like time.Time) have mappers registered by default. Mappers for custom types can be added using kong.??Mapper(...) options. Mappers are applied to fields in four ways:

  1. NamedMapper(string, Mapper) and using the tag key type:"<name>".
  2. KindMapper(reflect.Kind, Mapper).
  3. TypeMapper(reflect.Type, Mapper).
  4. ValueMapper(interface{}, Mapper), passing in a pointer to a field of the grammar.
ConfigureHelp(HelpOptions) and Help(HelpFunc) - customising help

The default help output is usually sufficient, but if not there are two solutions.

  1. Use ConfigureHelp(HelpOptions) to configure how help is formatted (see HelpOptions for details).
  2. Custom help can be wired into Kong via the Help(HelpFunc) option. The HelpFunc is passed a Context, which contains the parsed context for the current command-line. See the implementation of PrintHelp for an example.
Bind(...) - bind values for callback hooks and Run() methods

See the section on hooks for details.

Other options

The full set of options can be found here.

Documentation

Overview

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

Constants

This section is empty.

Variables

This section is empty.

Functions

func ApplyDefaults added in v0.1.17 

func ApplyDefaults(target interface{}, 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 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 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 ...interface{}) error
}

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

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 ...interface{}) error
}

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

type BeforeResolve 

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

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

type BoolMapper 

type BoolMapper interface {
	IsBool() bool
}

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

This is used solely for formatting help.

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 interface{}, 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 added in v0.1.17 

func (c *Context) ApplyDefaults() error

ApplyDefaults if they are not already set.

func (*Context) Bind 

func (c *Context) Bind(args ...interface{})

Bind adds bindings to the Context.

func (*Context) BindTo 

func (c *Context) BindTo(impl, iface interface{})

BindTo adds a binding to the Context.

This will typically have to be called like so: 

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

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) interface{}

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 added in v0.1.17 

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(bindings ...interface{}) (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.

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 Error 

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

Error reported by Kong.

func (Error) Error 

func (e Error) Error() string

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       string // Logical grouping when displaying. May also be used by configuration loaders to group options logically.
	PlaceHolder string
	Env         string
	Short       rune
	Hidden      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 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

	// 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
}

HelpOptions for HelpPrinters.

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 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 interface{}, options ...Option) *Kong

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

func New 

func New(grammar interface{}, 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 ...interface{}) *Kong

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

func (*Kong) FatalIfErrorf 

func (k *Kong) FatalIfErrorf(err error, args ...interface{})

FatalIfErrorf terminates with an error message if err != nil.

func (*Kong) Fatalf 

func (k *Kong) Fatalf(format string, args ...interface{})

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

func (*Kong) LoadConfig 

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

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

"path" will have ~/ 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 ...interface{}) *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 MappverValue 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.

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      string
	Hidden     bool
	Flags      []*Flag
	Positional []*Positional
	Children   []*Node
	Target     reflect.Value // Pointer to the value in the grammar that this Node is associated with.
	Tag        *Tag

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

func (n *Node) Depth() int

Depth of the command from the application root.

func (*Node) Find 

func (n *Node) Find(ptr interface{}) *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 Bind 

func Bind(args ...interface{}) 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 BindTo 

func BindTo(impl, iface interface{}) Option

BindTo allows binding of implementations to interfaces. 

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

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.

~ expansion will occur on the provided paths.

func ConfigureHelp 

func ConfigureHelp(options HelpOptions) Option

ConfigureHelp sets the HelpOptions to use for printing help.

func Description 

func Description(description string) Option

Description sets the application description.

func Exit 

func Exit(exit func(int)) Option

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

func Help 

func Help(help HelpPrinter) Option

Help printer to use.

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 Resolvers 

func Resolvers(resolvers ...Resolver) Option

Resolvers registers flag resolvers.

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 ValueMapper 

func ValueMapper(ptr interface{}, mapper Mapper) Option

ValueMapper registers a mapper to a field value.

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

func (p *ParseError) Cause() error

Cause returns the original cause of the error.

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
}

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.

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 interface{}, 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) (interface{}, 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.

Hyphens in flag names are replaced with underscores.

type ResolverFunc 

type ResolverFunc func(context *Context, parent *Path, flag *Flag) (interface{}, error)

ResolverFunc is a convenience type for non-validating Resolvers.

func (ResolverFunc) Resolve 

func (r ResolverFunc) Resolve(context *Context, parent *Path, flag *Flag) (interface{}, 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 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) 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 added in v0.1.17 

func (s *Scanner) PopValueInto(context string, target interface{}) 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 interface{}) *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 interface{}, 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
	Default     string
	Format      string
	PlaceHolder string
	Env         string
	Short       rune
	Hidden      bool
	Sep         rune
	Enum        string
	Group       string
	Vars        Vars
	Prefix      string // Optional prefix on anonymous structs. All sub-flags will have this prefix.
	Embed       bool
	// 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) Has 

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

Has returns true if the tag contained the given key.

type Token 

type Token struct {
	Value interface{}
	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 added in v0.1.17 

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

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 added in v0.1.17 

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

func (v *Value) IsBool() bool

IsBool returns true if the underlying value is a boolean.

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 added in v0.1.17 

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

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

BeforeApply 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

View all Source files

Directories

Path Synopsis
_examples
docker
nolint nolint
 nolint nolint
server
nolint: govet
 nolint: govet
shell

Jump to

Keyboard shortcuts

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