cli

package
v3.0.25+incompatible Latest Latest
Warning

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

 Go to latest Published: Sep 2, 2019 License: Apache-2.0 Imports: 12 Imported by: 0

README

Aliyun CLI Toolkit

Because aliyun cli need process unknown flags,and the following popular library did not support this feature

Code Structure

Command

.Run

.Help

Flag
FlagSet
Ctx
i18n
TODO

Documentation

Overview

Copyright 1999-2019 Alibaba Group Holding Limited

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Index

Examples

Constants

View Source 
const (
	ColorOff = "\033[0m" // Reset Color
	// Regular Colors
	Black  = "\033[0;30m" // Black
	Red    = "\033[0;31m" // Red
	Green  = "\033[0;32m" // Green
	Yellow = "\033[0;33m" // Yellow
	Blue   = "\033[0;34m" // Blue
	Purple = "\033[0;35m" // Purple
	Cyan   = "\033[0;36m" // Cyan
	White  = "\033[0;37m" // White

	// Bold
	BBlack  = "\033[1;30m" // Black
	BRed    = "\033[1;31m" // Red
	BGreen  = "\033[1;32m" // Green
	BYellow = "\033[1;33m" // Yellow
	BBlue   = "\033[1;34m" // Blue
	BPurple = "\033[1;35m" // Purple
	BCyan   = "\033[1;36m" // Cyan
	BWhite  = "\033[1;37m" // White

	// Underline
	UBlack  = "\033[4;30m" // Black
	URed    = "\033[4;31m" // Red
	UGreen  = "\033[4;32m" // Green
	UYellow = "\033[4;33m" // Yellow
	UBlue   = "\033[4;34m" // Blue
	UPurple = "\033[4;35m" // Purple
	UCyan   = "\033[4;36m" // Cyan
	UWhite  = "\033[4;37m" // White

	// Background
	OnBlack  = "\033[40m" // Black
	OnRed    = "\033[41m" // Red
	OnGreen  = "\033[42m" // Green
	OnYellow = "\033[43m" // Yellow
	OnBlue   = "\033[44m" // Blue
	OnPurple = "\033[45m" // Purple
	OnCyan   = "\033[46m" // Cyan
	OnWhite  = "\033[47m" // White

	// High Intensty
	IBlack  = "\033[0;90m" // Black
	IRed    = "\033[0;91m" // Red
	IGreen  = "\033[0;92m" // Green
	IYellow = "\033[0;93m" // Yellow
	IBlue   = "\033[0;94m" // Blue
	IPurple = "\033[0;95m" // Purple
	ICyan   = "\033[0;96m" // Cyan
	IWhite  = "\033[0;97m" // White

	// Bold High Intensty
	BIBlack  = "\033[1;90m" // Black
	BIRed    = "\033[1;91m" // Red
	BIGreen  = "\033[1;92m" // Green
	BIYellow = "\033[1;93m" // Yellow
	BIBlue   = "\033[1;94m" // Blue
	BIPurple = "\033[1;95m" // Purple
	BICyan   = "\033[1;96m" // Cyan
	BIWhite  = "\033[1;97m" // White

	// High Intensty backgrounds
	OnIBlack  = "\033[0;100m" // Black
	OnIRed    = "\033[0;101m" // Red
	OnIGreen  = "\033[0;102m" // Green
	OnIYellow = "\033[0;103m" // Yellow
	OnIBlue   = "\033[0;104m" // Blue
	OnIPurple = "\033[10;95m" // Purple
	OnICyan   = "\033[0;106m" // Cyan
	OnIWhite  = "\033[0;107m" // White
)
View Source 
const (
	DebugColor   = White
	InfoColor    = Cyan
	NoticeColor  = BYellow
	WarningColor = BPurple
	ErrorColor   = BRed
)
View Source 
const (
	AssignedNone       = AssignedMode(-1)
	AssignedDefault    = AssignedMode(0)
	AssignedOnce       = AssignedMode(1)
	AssignedRepeatable = AssignedMode(9)
)
View Source 
const (
	Ins = iota
	Del
	Sub
	Match
)
View Source 
const DefaultSuggestDistance = 2

Variables

View Source 
var (
	Version = "0.0.1"
)

This variable is replaced in compile time `-ldflags "-X 'github.com/aliyun/aliyun-cli/cli.Version=${VERSION}'"`

Functions

func APIListColor 

func APIListColor() string

func CalculateStringDistance 

func CalculateStringDistance(source string, target string) int

func Debug 

func Debug(w io.Writer, a ...interface{}) (n int, err error)

func Debugf 

func Debugf(w io.Writer, format string, args ...interface{}) (n int, err error)

func DefaultWriter 

func DefaultWriter() io.Writer

func DisableColor 

func DisableColor()

func DisableExitCode 

func DisableExitCode()

func DistanceForMatrix 

func DistanceForMatrix(matrix [][]int) int

DistanceForMatrix reads the edit distance off the given Levenshtein matrix.

func DistanceForStrings 

func DistanceForStrings(source []rune, target []rune, op Options) int

DistanceForStrings returns the edit distance between source and target.

It has a runtime proportional to len(source) * len(target) and memory use proportional to len(target).

Example 
source := "a"
target := "aa"
distance := DistanceForStrings([]rune(source), []rune(target), DefaultOptions)
fmt.Printf(`Distance between "%s" and "%s" computed as %d`, source, target, distance)

Output:

Distance between "a" and "aa" computed as 1

func EnableColor 

func EnableColor()

func EnableExitCode 

func EnableExitCode()

func Error 

func Error(w io.Writer, a ...interface{}) (n int, err error)

func Errorf 

func Errorf(w io.Writer, format string, args ...interface{}) (n int, err error)

func Exit 

func Exit(code int)

func GetVersion 

func GetVersion() string

func Info 

func Info(w io.Writer, a ...interface{}) (n int, err error)

func Infof 

func Infof(w io.Writer, format string, args ...interface{}) (n int, err error)

func LogMatrix 

func LogMatrix(source []rune, target []rune, matrix [][]int)

LogMatrix writes a visual representation of the given matrix for the given strings to os.Stderr. This function is deprecated, use WriteMatrix(source, target, matrix, os.Stderr) instead.

func MatrixForStrings 

func MatrixForStrings(source []rune, target []rune, op Options) [][]int

MatrixForStrings generates a 2-D array representing the dynamic programming table used by the Levenshtein algorithm, as described e.g. here: http://www.let.rug.nl/kleiweg/lev/ The reason for putting the creation of the table into a separate function is that it cannot only be used for reading of the edit distance between two strings, but also e.g. to backtrace an edit script that provides an alignment between the characters of both strings.

func NewErrorWithTip 

func NewErrorWithTip(err error, tipFormat string, args ...interface{}) error

func NewInvalidCommandError 

func NewInvalidCommandError(name string, ctx *Context) error

func NewInvalidFlagError 

func NewInvalidFlagError(name string, ctx *Context) error

func Notice 

func Notice(w io.Writer, a ...interface{}) (n int, err error)

func Noticef 

func Noticef(w io.Writer, format string, args ...interface{}) (n int, err error)

func PlatformCompatible 

func PlatformCompatible()

func Print 

func Print(w io.Writer, a ...interface{}) (n int, err error)

func PrintSuggestions 

func PrintSuggestions(ctx *Context, lang string, ss []string)

func PrintWithColor 

func PrintWithColor(w io.Writer, color string, a ...interface{}) (n int, err error)

func Printf 

func Printf(w io.Writer, format string, args ...interface{}) (n int, err error)

func PrintfWithColor 

func PrintfWithColor(w io.Writer, color string, format string, args ...interface{}) (n int, err error)

func Println 

func Println(w io.Writer, a ...interface{}) (n int, err error)

func ProductListColor 

func ProductListColor() string

func RatioForMatrix 

func RatioForMatrix(matrix [][]int) float64

RatioForMatrix returns the Levenshtein ratio for the given matrix. The ratio is computed as follows: 

(sourceLength + targetLength - distance) / (sourceLength + targetLength)

func RatioForStrings 

func RatioForStrings(source []rune, target []rune, op Options) float64

RatioForStrings returns the Levenshtein ratio for the given strings. The ratio is computed as follows: 

(sourceLength + targetLength - distance) / (sourceLength + targetLength)

func SetAPIListColor 

func SetAPIListColor(color string)

func SetProductListColor 

func SetProductListColor(color string)

func SplitString 

func SplitString(s string, sep string) []string

func SplitStringWithPrefix 

func SplitStringWithPrefix(s string, splitters string) (string, string, bool)

SplitStringWithPrefix TODO can use function string.SplitN to replace

func UnquoteString 

func UnquoteString(s string) string

func Warning 

func Warning(w io.Writer, a ...interface{}) (n int, err error)

func Warningf 

func Warningf(w io.Writer, format string, args ...interface{}) (n int, err error)

func WriteMatrix 

func WriteMatrix(source []rune, target []rune, matrix [][]int, writer io.Writer)

WriteMatrix writes a visual representation of the given matrix for the given strings to the given writer.

Example 
source := []rune("neighbor")
target := []rune("Neighbour")
matrix := MatrixForStrings(source, target, DefaultOptions)
WriteMatrix(source, target, matrix, os.Stdout)

Output:

      N  e  i  g  h  b  o  u  r
   0  1  2  3  4  5  6  7  8  9
n  1  2  3  4  5  6  7  8  9 10
e  2  3  2  3  4  5  6  7  8  9
i  3  4  3  2  3  4  5  6  7  8
g  4  5  4  3  2  3  4  5  6  7
h  5  6  5  4  3  2  3  4  5  6
b  6  7  6  5  4  3  2  3  4  5
o  7  8  7  6  5  4  3  2  3  4
r  8  9  8  7  6  5  4  3  4  3

Types

type AssignedMode 

type AssignedMode int

type Command 

type Command struct {
	// Command Name
	Name string

	// Short is the short description shown in the 'help' output.
	Short *i18n.Text

	// Long is the long message shown in the 'help <this-command>' output.
	Long *i18n.Text

	// Syntax for usage
	Usage string

	// Sample command
	Sample string

	// Enable unknown flags
	EnableUnknownFlag bool

	// enable suggest distance,
	// disable -1
	// 0: default distance
	SuggestDistance int

	// Hidden command
	Hidden bool

	// Run, command error will be catch
	Run func(ctx *Context, args []string) error

	// Help
	Help func(ctx *Context, args []string) error

	// auto compete
	AutoComplete func(ctx *Context, args []string) []string
	// contains filtered or unexported fields
}

func NewAutoCompleteCommand 

func NewAutoCompleteCommand() *Command

func NewVersionCommand 

func NewVersionCommand() *Command

func (*Command) AddSubCommand 

func (c *Command) AddSubCommand(cmd *Command)

func (*Command) Execute 

func (c *Command) Execute(ctx *Context, args []string)

func (*Command) ExecuteComplete 

func (c *Command) ExecuteComplete(ctx *Context, args []string)

func (*Command) Flags 

func (c *Command) Flags() *FlagSet

func (*Command) GetSubCommand 

func (c *Command) GetSubCommand(s string) *Command

func (*Command) GetSuggestDistance 

func (c *Command) GetSuggestDistance() int

func (*Command) GetSuggestions 

func (c *Command) GetSuggestions(s string) []string

func (*Command) GetUsageWithParent 

func (c *Command) GetUsageWithParent() string

func (*Command) PrintFailed 

func (c *Command) PrintFailed(ctx *Context, err error, suggestion string)

func (*Command) PrintFlags 

func (c *Command) PrintFlags(ctx *Context)

func (*Command) PrintHead 

func (c *Command) PrintHead(ctx *Context)

func (*Command) PrintSample 

func (c *Command) PrintSample(ctx *Context)

func (*Command) PrintSubCommands 

func (c *Command) PrintSubCommands(ctx *Context)

func (*Command) PrintTail 

func (c *Command) PrintTail(ctx *Context)

func (*Command) PrintUsage 

func (c *Command) PrintUsage(ctx *Context)

type Completion 

type Completion struct {
	Current string
	Args    []string
	// contains filtered or unexported fields
}

func ParseCompletion 

func ParseCompletion(line, point string) *Completion

func ParseCompletionForShell 

func ParseCompletionForShell() *Completion

func (*Completion) GetArgs 

func (c *Completion) GetArgs() []string

func (*Completion) GetCurrent 

func (c *Completion) GetCurrent() string

type Context 

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

CLI Command Context

func NewCommandContext 

func NewCommandContext(w io.Writer) *Context

func (*Context) CheckFlags 

func (ctx *Context) CheckFlags() error

func (*Context) Command 

func (ctx *Context) Command() *Command

func (*Context) Completion 

func (ctx *Context) Completion() *Completion

func (*Context) EnterCommand 

func (ctx *Context) EnterCommand(cmd *Command)

Before go into the sub command, we need traverse flags and merge with parent

func (*Context) Flags 

func (ctx *Context) Flags() *FlagSet

func (*Context) IsHelp 

func (ctx *Context) IsHelp() bool

func (*Context) SetCompletion 

func (ctx *Context) SetCompletion(completion *Completion)

func (*Context) SetUnknownFlags 

func (ctx *Context) SetUnknownFlags(flags *FlagSet)

func (*Context) UnknownFlags 

func (ctx *Context) UnknownFlags() *FlagSet

func (*Context) Writer 

func (ctx *Context) Writer() io.Writer

type EditOperation 

type EditOperation int

func (EditOperation) String 

func (operation EditOperation) String() string

type EditScript 

type EditScript []EditOperation

func EditScriptForMatrix 

func EditScriptForMatrix(matrix [][]int, op Options) EditScript

EditScriptForMatrix returns an optimal edit script based on the given Levenshtein matrix.

func EditScriptForStrings 

func EditScriptForStrings(source []rune, target []rune, op Options) EditScript

EditScriptForStrings returns an optimal edit script to turn source into target.

type ErrorWithTip 

type ErrorWithTip interface {
	GetTip(lang string) string
}

If command.Execute return Noticeable error, print i18n Notice under error information

type Field 

type Field struct {
	//
	// appear in `--flag key1=value1, key2=value2`
	// if Key assigned with "", it can used with `--flag value1 value2`
	Key string

	//
	// if Required is true, this field must be assigned
	Required bool

	//
	// if Repeatable is true, this field can appear multiply times, eg: "--flag key1=value1 key2=value2"
	Repeatable bool

	//
	// if field not appear, use this value, not used with Required
	DefaultValue string

	//
	// Message show
	Short *i18n.Text
	// contains filtered or unexported fields
}

func (*Field) SetAssigned 

func (f *Field) SetAssigned(istrue bool)

func (*Field) SetValue 

func (f *Field) SetValue(value string)

type Flag 

type Flag struct {
	// Name of flag --{Name}
	Name string

	// Flag is the single characters
	Shorthand rune

	// Message print with --help command
	Short *i18n.Text

	// Message print with `help --flag` command
	Long *i18n.Text

	// If DefaultValue is not "" and Required is true, if flag is not assign
	//   GetValue() will return DefaultValue, and IsAssigned() will be false
	DefaultValue string

	// If Required is true, the flag must be assigned with `--flag value` or DefaultValue is not empty
	Required bool

	// Enable flag has alias names
	Aliases []string

	// Ref to AssignedMode
	// `AssignedNone`: 		flag only appear with `--flag1` `--flag2`
	// `AssignedDefault`: 	flag can appear with `--flag1` or `--flag1 value1`
	// `AssignedOnce`: 		flag only appear with `--flag1 value1`
	// `AssignedRepeatable`: flag can appear multi times sample: `--flag1 [v1] [v2] [v3] [field1=value1]`, use with Fields
	AssignedMode AssignedMode

	// If Persistent is true, the flag can apply to child commands
	Persistent bool

	// If Hidden is true, it will not appear in --help mode
	Hidden bool

	// Using in FlagSet.GetByCategory()...
	Category string

	// Use to validate flag is in correct format
	Validate func(f *Flag) error

	// Flag can assigned with --flag field1=value1 field2=value2 value3 ...
	// must used with AssignedMode=AssignedRepeatable
	Fields []Field

	// Flag can't appear with other flags, use Flag.Name
	ExcludeWith []string
	// contains filtered or unexported fields
}

func HelpFlag 

func HelpFlag(fs *FlagSet) *Flag

func NewHelpFlag 

func NewHelpFlag() *Flag

func (*Flag) GetFieldValue 

func (f *Flag) GetFieldValue(key string) (string, bool)

--flag field1=value1

func (*Flag) GetFieldValues 

func (f *Flag) GetFieldValues(key string) []string

func (*Flag) GetFormations 

func (f *Flag) GetFormations() []string

get all appears forms, maybe {"--Name", "--Alias1", "-Shorthand"}

func (*Flag) GetIntegerOrDefault 

func (f *Flag) GetIntegerOrDefault(def int) int

TODO: flag support integer validate return def if Flag is not assign or assign failed

func (*Flag) GetStringOrDefault 

func (f *Flag) GetStringOrDefault(def string) string

return def if Flag is not assigned

func (*Flag) GetValue 

func (f *Flag) GetValue() (string, bool)

return flag value, if not assigned return f.DefaultValue 

for `AssignedMode == AssignedRepeatable`. Use GetValues() to get all values

func (*Flag) GetValues 

func (f *Flag) GetValues() []string

for `AssignedMode == AssignedRepeatable` flag, return values

func (*Flag) IsAssigned 

func (f *Flag) IsAssigned() bool

return true if flag appeared, either `--flag1` or `--flag1 value1`

func (*Flag) SetAssigned 

func (f *Flag) SetAssigned(istrue bool)

func (*Flag) SetValue 

func (f *Flag) SetValue(value string)

func (*Flag) SetValues 

func (f *Flag) SetValues(values []string)

type FlagSet 

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

func NewFlagSet 

func NewFlagSet() *FlagSet

func (*FlagSet) Add 

func (fs *FlagSet) Add(f *Flag)

call from user program, if flag duplicated, panic!

func (*FlagSet) AddByName 

func (fs *FlagSet) AddByName(name string) (*Flag, error)

add by name, not support add by shorthand

func (*FlagSet) Flags 

func (fs *FlagSet) Flags() []*Flag

traverse all values

func (*FlagSet) Get 

func (fs *FlagSet) Get(name string) *Flag

get flag by name, sample --name

func (*FlagSet) GetByShorthand 

func (fs *FlagSet) GetByShorthand(c rune) *Flag

get flag by shorthand, sample -a

func (*FlagSet) GetSuggestions 

func (fs *FlagSet) GetSuggestions(name string, distance int) []string

get suggestions

func (*FlagSet) GetValue 

func (fs *FlagSet) GetValue(name string) (string, bool)

get value by flag name, not recommended

type InvalidCommandError 

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

OUTPUT: Error: "'%s' is not a valid command

{Hint}

func (*InvalidCommandError) Error 

func (e *InvalidCommandError) Error() string

func (*InvalidCommandError) GetSuggestions 

func (e *InvalidCommandError) GetSuggestions() []string

type InvalidFlagError 

type InvalidFlagError struct {
	Flag string
	// contains filtered or unexported fields
}

func (*InvalidFlagError) Error 

func (e *InvalidFlagError) Error() string

func (*InvalidFlagError) GetSuggestions 

func (e *InvalidFlagError) GetSuggestions() []string

type MatchFunction 

type MatchFunction func(rune, rune) bool

type Options 

type Options struct {
	InsCost int
	DelCost int
	SubCost int
	Matches MatchFunction
}
var DefaultOptions Options = Options{
	InsCost: 1,
	DelCost: 1,
	SubCost: 2,
	Matches: func(sourceCharacter rune, targetCharacter rune) bool {
		return sourceCharacter == targetCharacter
	},
}

DefaultOptions is the default options: insertion cost is 1, deletion cost is 1, substitution cost is 2, and two runes match iff they are the same.

type Output 

type Output struct {
}

func NewOutput 

func NewOutput() *Output

func (*Output) Print 

func (o *Output) Print(w io.Writer, a ...interface{}) (n int, err error)

func (*Output) Printf 

func (o *Output) Printf(w io.Writer, format string, a ...interface{}) (n int, err error)

func (*Output) Println 

func (o *Output) Println(w io.Writer, a ...interface{}) (n int, err error)

type Parser 

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

func NewParser 

func NewParser(args []string, detector flagDetector) *Parser

func (*Parser) GetRemains 

func (p *Parser) GetRemains() []string

func (*Parser) ReadAll 

func (p *Parser) ReadAll() ([]string, error)

func (*Parser) ReadNextArg 

func (p *Parser) ReadNextArg() (arg string, more bool, err error)

type Suggester 

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

helper class for Suggester

func NewSuggester 

func NewSuggester(v string, distance int) *Suggester

func (*Suggester) Apply 

func (a *Suggester) Apply(s string)

func (*Suggester) GetResults 

func (a *Suggester) GetResults() []string

type SuggestibleError 

type SuggestibleError interface {
	GetSuggestions() []string
}

error with suggestions

Source Files

View all Source files

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.