open-consul/command/flags/usage.go

115 lines
2.4 KiB
Go

package flags
import (
"bytes"
"flag"
"fmt"
"io"
"strings"
text "github.com/kr/text"
)
func Usage(txt string, flags *flag.FlagSet) string {
u := &Usager{
Usage: txt,
Flags: flags,
}
return u.String()
}
type Usager struct {
Usage string
Flags *flag.FlagSet
}
func (u *Usager) String() string {
out := new(bytes.Buffer)
out.WriteString(strings.TrimSpace(u.Usage))
out.WriteString("\n")
out.WriteString("\n")
if u.Flags != nil {
f := &HTTPFlags{}
clientFlags := f.ClientFlags()
serverFlags := f.ServerFlags()
var httpFlags, cmdFlags *flag.FlagSet
u.Flags.VisitAll(func(f *flag.Flag) {
if contains(clientFlags, f) || contains(serverFlags, f) {
if httpFlags == nil {
httpFlags = flag.NewFlagSet("", flag.ContinueOnError)
}
httpFlags.Var(f.Value, f.Name, f.Usage)
} else {
if cmdFlags == nil {
cmdFlags = flag.NewFlagSet("", flag.ContinueOnError)
}
cmdFlags.Var(f.Value, f.Name, f.Usage)
}
})
if httpFlags != nil {
printTitle(out, "HTTP API Options")
httpFlags.VisitAll(func(f *flag.Flag) {
printFlag(out, f)
})
}
if cmdFlags != nil {
printTitle(out, "Command Options")
cmdFlags.VisitAll(func(f *flag.Flag) {
printFlag(out, f)
})
}
}
return strings.TrimRight(out.String(), "\n")
}
// printTitle prints a consistently-formatted title to the given writer.
func printTitle(w io.Writer, s string) {
fmt.Fprintf(w, "%s\n\n", s)
}
// printFlag prints a single flag to the given writer.
func printFlag(w io.Writer, f *flag.Flag) {
example, _ := flag.UnquoteUsage(f)
if example != "" {
fmt.Fprintf(w, " -%s=<%s>\n", f.Name, example)
} else {
fmt.Fprintf(w, " -%s\n", f.Name)
}
indented := wrapAtLength(f.Usage, 5)
fmt.Fprintf(w, "%s\n\n", indented)
}
// contains returns true if the given flag is contained in the given flag
// set or false otherwise.
func contains(fs *flag.FlagSet, f *flag.Flag) bool {
if fs == nil {
return false
}
var in bool
fs.VisitAll(func(hf *flag.Flag) {
in = in || f.Name == hf.Name
})
return in
}
// maxLineLength is the maximum width of any line.
const maxLineLength int = 72
// wrapAtLength wraps the given text at the maxLineLength, taking into account
// any provided left padding.
func wrapAtLength(s string, pad int) string {
wrapped := text.Wrap(s, maxLineLength-pad)
lines := strings.Split(wrapped, "\n")
for i, line := range lines {
lines[i] = strings.Repeat(" ", pad) + line
}
return strings.Join(lines, "\n")
}