sflag

README

Usage

package main

import (
	"fmt"
	"time"

	"github.com/konoui/lipo/pkg/sflag"
)

func example1() {
	fs := sflag.NewFlagSet("simple usage")
	debug := fs.Bool("debug", "enable debug mode", sflag.WithShortName("d")) // allow -debug and -d
	values := fs.Strings("values", "multiple values")
	err := fs.Parse([]string{"-values", "a", "b", "c", "-d", "arg1", "arg2"})
	if err != nil {
		panic(err)
	}

	fmt.Println(fs.Args())    // [arg1 arg2]
	fmt.Println(debug.Get())  // true
	fmt.Println(values.Get()) // [a b c]
}

func example2() {
	fs := sflag.NewFlagSet("a custom flag definition")

	timeValue := sflag.NewValue(new(time.Duration), time.ParseDuration)
	timeFlag := sflag.Register(fs, timeValue, "time", "-time 20s", sflag.WithDenyDuplicate())

	p := new([]time.Duration)
	timesValue := sflag.NewValue(p, func(v string) ([]time.Duration, error) {
		pd, err := time.ParseDuration(v)
		if err != nil {
			return nil, err
		}
		*p = append(*p, pd)
		return *p, nil
	})
	timesFlag := sflag.Register(fs, timesValue, "times", "-times 20s -times 30h")

	err := fs.Parse([]string{"-time", "7200s", "-times", "20m", "-times", "30h"})
	if err != nil {
		panic(err)
	}

	fmt.Println(timeFlag.Get().Hours()) // 2
	fmt.Println(timesFlag.Get())        // [20m0s 30h0m0s]
}

func main() {
	example1()
	example2()
}

Documentation

Index

• Constants
• func UsageFunc(groups ...*Group) func() string
• type Flag
• type FlagGetter
• type FlagOpt
  • func WithDenyDuplicate() FlagOpt
  • func WithShortName(short string) FlagOpt
• type FlagRef
  • func Register[T any](f *FlagSet, v *Value[T], name, usage string, opts ...FlagOpt) *FlagRef[T]
  • func (fr *FlagRef[T]) Flag() *Flag
  • func (fr *FlagRef[T]) Get() T
• type FlagSet
  • func NewFlagSet(name string) *FlagSet
  • func (f *FlagSet) Args() []string
  • func (f *FlagSet) Bool(name, usage string, opts ...FlagOpt) *FlagRef[bool]
  • func (f *FlagSet) FixedStringFlags(name, usage string, opts ...FlagOpt) *FlagRef[[][2]string]
  • func (f *FlagSet) NewGroup(name string) *Group
  • func (f *FlagSet) Parse(args []string) error
  • func (f *FlagSet) String(name, usage string, opts ...FlagOpt) *FlagRef[string]
  • func (f *FlagSet) StringFlags(name, usage string, opts ...FlagOpt) *FlagRef[[]string]
  • func (f *FlagSet) Strings(name, usage string, opts ...FlagOpt) *FlagRef[[]string]
• type FlagType
  • func (t FlagType) String() string
• type Group
  • func LookupGroup(groups ...*Group) (*Group, error)
  • func (g *Group) AddDescription(s string) *Group
  • func (g *Group) AddOptional(fg FlagGetter) *Group
  • func (g *Group) AddRequired(fg FlagGetter) *Group
  • func (g *Group) String() string
  • func (g *Group) Usage() string
• type Value
  • func NewValue[T any](p *T, converter func(v string) (T, error)) *Value[T]
  • func NewValues[T any](p *T, converter func(v string) (T, error), capper func() int) *Value[T]

Constants

const (
	CapNoLimit = -1
)

Functions

func UsageFunc

func UsageFunc(groups ...*Group) func() string

Types

type Flag

type Flag struct {
	Name      string
	ShortName string
	Usage     string
	// contains filtered or unexported fields
}

type FlagGetter

type FlagGetter interface {
	Flag() *Flag
}

type FlagOpt

type FlagOpt func(*Flag)

func WithDenyDuplicate

func WithDenyDuplicate() FlagOpt

WithDenyDuplicate Parse() returns an error if encountering duplicated flags are specified. This is used for a custom flag definition. Pre-defined flags(Bool/String etc) are enabled by default.

func WithShortName

func WithShortName(short string) FlagOpt

type FlagRef

type FlagRef[T any] struct {
	// contains filtered or unexported fields
}

FlagRef is a wrapper to access the Flag and the flag value.

func Register

func Register[T any](f *FlagSet, v *Value[T], name, usage string, opts ...FlagOpt) *FlagRef[T]

Register registers a Value with a Name and an Usage as a Flag This is used to define a custom flag type.

func (*FlagRef[T]) Flag

func (fr *FlagRef[T]) Flag() *Flag

Flag returns the Flag to access the flag name and the usage.

func (*FlagRef[T]) Get

func (fr *FlagRef[T]) Get() T

Get returns a typed flag value

type FlagSet

type FlagSet struct {
	Usage func() string
	// contains filtered or unexported fields
}

func NewFlagSet

func NewFlagSet(name string) *FlagSet

func (*FlagSet) Args

func (f *FlagSet) Args() []string

func (*FlagSet) Bool

func (f *FlagSet) Bool(name, usage string, opts ...FlagOpt) *FlagRef[bool]

Bool represents `-flag` NOT `-flag true/false`

func (*FlagSet) FixedStringFlags

func (f *FlagSet) FixedStringFlags(name, usage string, opts ...FlagOpt) *FlagRef[[][2]string]

FixedStringFlags represents `-flag <value1> <value2> -flag <value3> <value4> -flag ...` This is a reference implementation

func (*FlagSet) NewGroup

func (f *FlagSet) NewGroup(name string) *Group

func (*FlagSet) Parse

func (f *FlagSet) Parse(args []string) error

func (*FlagSet) String

func (f *FlagSet) String(name, usage string, opts ...FlagOpt) *FlagRef[string]

String represents `-flag <value>`

func (*FlagSet) StringFlags

func (f *FlagSet) StringFlags(name, usage string, opts ...FlagOpt) *FlagRef[[]string]

StringFlags represents `-flag <value1> -flag <value2> -flag <value3> -flag ...`

func (*FlagSet) Strings

func (f *FlagSet) Strings(name, usage string, opts ...FlagOpt) *FlagRef[[]string]

Strings represents `-flag <value1> <value2> <value3> ...`

type FlagType

type FlagType int

const (
	TypeRequired FlagType = iota + 1
	TypeOptional
)

func (FlagType) String

func (t FlagType) String() string

type Group

type Group struct {
	Name string
	// contains filtered or unexported fields
}

func LookupGroup

func LookupGroup(groups ...*Group) (*Group, error)

func (*Group) AddDescription

func (g *Group) AddDescription(s string) *Group

func (*Group) AddOptional

func (g *Group) AddOptional(fg FlagGetter) *Group

func (*Group) AddRequired

func (g *Group) AddRequired(fg FlagGetter) *Group

func (*Group) String

func (g *Group) String() string

func (*Group) Usage

func (g *Group) Usage() string

type Value

type Value[T any] struct {
	// contains filtered or unexported fields
}

Value please use NewValue(s) function instead of the definition

func NewValue

func NewValue[T any](p *T, converter func(v string) (T, error)) *Value[T]

NewValue is used for a single value definition. e.g.) bool, string, int. When implementing `-flag value1 -flag value2 -flag value3`, it can be also useful.

func NewValues

func NewValues[T any](p *T, converter func(v string) (T, error), capper func() int) *Value[T]

NewValues is used for a slice definition. e.g. -flag value1 value2 value3