package getopt

import "src.elv.sh/pkg/getopt"

Package getopt implements a command-line argument parser.

It tries to cover all common styles of option syntaxes, and provides context information when given a partial input. It is mainly useful for writing completion engines and wrapper programs.

If you are looking for an option parser for your go program, consider using the flag package in the standard library instead.

Index

Package Files

getopt.go string.go

type Config

type Config uint

Config configurates the parsing behavior.

const (
    // DoubleDashTerminatesOptions indicates that all elements after an argument
    // "--" are treated as arguments.
    DoubleDashTerminatesOptions Config = 1 << iota
    // FirstArgTerminatesOptions indicates that all elements after the first
    // argument are treated as arguments.
    FirstArgTerminatesOptions
    // LongOnly indicates that long options may be started by either one or two
    // dashes, and short options are not allowed. Should replicate the behavior
    // of getopt_long_only and the
    // flag package of the Go standard library.
    LongOnly
    // GNUGetoptLong is a configuration that should replicate the behavior of
    // GNU getopt_long.
    GNUGetoptLong = DoubleDashTerminatesOptions
    // POSIXGetopt is a configuration that should replicate the behavior of
    // POSIX getopt.
    POSIXGetopt = DoubleDashTerminatesOptions | FirstArgTerminatesOptions
)

func (Config) HasAll

func (conf Config) HasAll(flags Config) bool

HasAll tests whether a configuration has all specified flags set.

func (Config) String

func (i Config) String() string

type Context

type Context struct {
    // The nature of the context.
    Type ContextType
    // Current option, with a likely incomplete Argument. Non-nil when Type is
    // OptionArgument.
    Option *ParsedOption
    // Current partial long option name or argument. Non-empty when Type is
    // LongOption or Argument.
    Text string
}

Context indicates what may come after the supplied argument list.

type ContextType

type ContextType uint

ContextType encodes what may be appended to the last element of the argument list.

const (
    // NewOptionOrArgument indicates that the last element may be either a new
    // option or a new argument. Returned when it is an empty string.
    NewOptionOrArgument ContextType = iota
    // NewOption indicates that the last element must be new option, short or
    // long. Returned when it is "-".
    NewOption
    // NewLongOption indicates that the last element must be a new long option.
    // Returned when it is "--".
    NewLongOption
    // LongOption indicates that the last element is a long option, but not its
    // argument. The partial name of the long option is stored in Context.Text.
    LongOption
    // ChainShortOption indicates that a new short option may be chained.
    // Returned when the last element consists of a chain of options that take
    // no arguments.
    ChainShortOption
    // OptionArgument indicates that the last element list must be an argument
    // to an option. The option in question is stored in Context.Option.
    OptionArgument
    // Argument indicates that the last element is an argument. The partial
    // argument is stored in Context.Text.
    Argument
)

func (ContextType) String

func (i ContextType) String() string

type Getopt

type Getopt struct {
    Options []*Option
    Config  Config
}

Getopt specifies the syntax of command-line arguments.

func (*Getopt) Parse

func (g *Getopt) Parse(elems []string) ([]*ParsedOption, []string, *Context)

Parse parses an argument list.

type HasArg

type HasArg uint

HasArg indicates whether an option takes an argument, and whether it is required.

const (
    // NoArgument indicates that an option takes no argument.
    NoArgument HasArg = iota
    // RequiredArgument indicates that an option must take an argument. The
    // argument can come either directly after a short option (-oarg), after a
    // long option followed by an equal sign (--long=arg), or as a subsequent
    // argument after the option (-o arg, --long arg).
    RequiredArgument
    // OptionalArgument indicates that an option takes an optional argument.
    // The argument can come either directly after a short option (-oarg) or
    // after a long option followed by an equal sign (--long=arg).
    OptionalArgument
)

func (HasArg) String

func (i HasArg) String() string

type Option

type Option struct {
    // Short option. Set to 0 for long-only.
    Short rune
    // Long option. Set to "" for short-only.
    Long string
    // Whether the option takes an argument, and whether it is required.
    HasArg HasArg
}

Option is a command-line option.

type ParsedOption

type ParsedOption struct {
    Option   *Option
    Long     bool
    Argument string
}

ParsedOption represents a parsed option.

Package getopt imports 2 packages (graph) and is imported by 1 packages. Updated 1 month ago.

.
Tools for package owners.