glenux-archive/spf13--cobra
1
0
Fork 0
mirror of https://github.com/spf13/cobra synced 2025-05-07 22:07:23 +00:00
Code Issues Projects Releases Packages Wiki Activity

make string ''\)\n' a constant and check error

Browse source
This commit is contained in:
umarcor 2019-06-07 18:52:28 +02:00
parent d6568bad2e
commit 826340688f
2 changed files with 69 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
bash_completions.go
View file

@ -19,9 +19,9 @@ const (
BashCompSubdirsInDir = "cobra_annotation_bash_completion_subdirs_in_dir" BashCompSubdirsInDir = "cobra_annotation_bash_completion_subdirs_in_dir"
) )
func writePreamble(buf *bytes.Buffer, name string) { func writePreamble(buf io.StringWriter, name string) {
buf.WriteString(fmt.Sprintf("# bash completion for %-36s -*- shell-script -*-\n", name)) WrStringAndCheck(buf, fmt.Sprintf("# bash completion for %-36s -*- shell-script -*-\n", name))
buf.WriteString(fmt.Sprintf(` WrStringAndCheck(buf, fmt.Sprintf(`
__%[1]s_debug() __%[1]s_debug()
{ {
if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
@ -282,10 +282,10 @@ __%[1]s_handle_word()
`, name)) `, name))
} }
func writePostscript(buf *bytes.Buffer, name string) { func writePostscript(buf io.StringWriter, name string) {
name = strings.Replace(name, ":", "__", -1) name = strings.Replace(name, ":", "__", -1)
buf.WriteString(fmt.Sprintf("__start_%s()\n", name)) WrStringAndCheck(buf, fmt.Sprintf("__start_%s()\n", name))
buf.WriteString(fmt.Sprintf(`{ WrStringAndCheck(buf, fmt.Sprintf(`{
local cur prev words cword local cur prev words cword
declare -A flaghash 2>/dev/null || : declare -A flaghash 2>/dev/null || :
declare -A aliashash 2>/dev/null || : declare -A aliashash 2>/dev/null || :
@ -311,33 +311,33 @@ func writePostscript(buf *bytes.Buffer, name string) {
} }
`, name)) `, name))
buf.WriteString(fmt.Sprintf(`if [[ $(type -t compopt) = "builtin" ]]; then WrStringAndCheck(buf, fmt.Sprintf(`if [[ $(type -t compopt) = "builtin" ]]; then
complete -o default -F __start_%s %s complete -o default -F __start_%s %s
else else
complete -o default -o nospace -F __start_%s %s complete -o default -o nospace -F __start_%s %s
fi fi
`, name, name, name, name)) `, name, name, name, name))
buf.WriteString("# ex: ts=4 sw=4 et filetype=sh\n") WrStringAndCheck(buf, "# ex: ts=4 sw=4 et filetype=sh\n")
} }
func writeCommands(buf *bytes.Buffer, cmd *Command) { func writeCommands(buf io.StringWriter, cmd *Command) {
buf.WriteString(" commands=()\n") WrStringAndCheck(buf, " commands=()\n")
for _, c := range cmd.Commands() { for _, c := range cmd.Commands() {
if !c.IsAvailableCommand() || c == cmd.helpCommand { if !c.IsAvailableCommand() || c == cmd.helpCommand {
continue continue
} }
buf.WriteString(fmt.Sprintf(" commands+=(%q)\n", c.Name())) WrStringAndCheck(buf, fmt.Sprintf(" commands+=(%q)\n", c.Name()))
writeCmdAliases(buf, c) writeCmdAliases(buf, c)
} }
buf.WriteString("\n") WrStringAndCheck(buf, "\n")
} }
func writeFlagHandler(buf *bytes.Buffer, name string, annotations map[string][]string, cmd *Command) { func writeFlagHandler(buf io.StringWriter, name string, annotations map[string][]string, cmd *Command) {
for key, value := range annotations { for key, value := range annotations {
switch key { switch key {
case BashCompFilenameExt: case BashCompFilenameExt:
buf.WriteString(fmt.Sprintf(" flags_with_completion+=(%q)\n", name)) WrStringAndCheck(buf, fmt.Sprintf(" flags_with_completion+=(%q)\n", name))
var ext string var ext string
if len(value) > 0 { if len(value) > 0 {
@ -345,17 +345,18 @@ func writeFlagHandler(buf *bytes.Buffer, name string, annotations map[string][]s
} else { } else {
ext = "_filedir" ext = "_filedir"
} }
buf.WriteString(fmt.Sprintf(" flags_completion+=(%q)\n", ext)) WrStringAndCheck(buf, fmt.Sprintf(" flags_completion+=(%q)\n", ext))
case BashCompCustom: case BashCompCustom:
buf.WriteString(fmt.Sprintf(" flags_with_completion+=(%q)\n", name)) WrStringAndCheck(buf, fmt.Sprintf(" flags_with_completion+=(%q)\n", name))
if len(value) > 0 { if len(value) > 0 {
handlers := strings.Join(value, "; ") handlers := strings.Join(value, "; ")
buf.WriteString(fmt.Sprintf(" flags_completion+=(%q)\n", handlers)) WrStringAndCheck(buf, fmt.Sprintf(" flags_completion+=(%q)\n", handlers))
} else { } else {
buf.WriteString(" flags_completion+=(:)\n") WrStringAndCheck(buf, " flags_completion+=(:)\n")
} }
case BashCompSubdirsInDir: case BashCompSubdirsInDir:
buf.WriteString(fmt.Sprintf(" flags_with_completion+=(%q)\n", name)) WrStringAndCheck(buf, fmt.Sprintf(" flags_with_completion+=(%q)\n", name))
var ext string var ext string
if len(value) == 1 { if len(value) == 1 {
@ -363,49 +364,51 @@ func writeFlagHandler(buf *bytes.Buffer, name string, annotations map[string][]s
} else { } else {
ext = "_filedir -d" ext = "_filedir -d"
} }
buf.WriteString(fmt.Sprintf(" flags_completion+=(%q)\n", ext)) WrStringAndCheck(buf, fmt.Sprintf(" flags_completion+=(%q)\n", ext))
} }
} }
} }
func writeShortFlag(buf *bytes.Buffer, flag *pflag.Flag, cmd *Command) { const cbn = "\")\n"
func writeShortFlag(buf io.StringWriter, flag *pflag.Flag, cmd *Command) {
name := flag.Shorthand name := flag.Shorthand
format := " " format := " "
if len(flag.NoOptDefVal) == 0 { if len(flag.NoOptDefVal) == 0 {
format += "two_word_" format += "two_word_"
} }
format += "flags+=(\"-%s\")\n" format += "flags+=(\"-%s" + cbn
buf.WriteString(fmt.Sprintf(format, name)) WrStringAndCheck(buf, fmt.Sprintf(format, name))
writeFlagHandler(buf, "-"+name, flag.Annotations, cmd) writeFlagHandler(buf, "-"+name, flag.Annotations, cmd)
} }
func writeFlag(buf *bytes.Buffer, flag *pflag.Flag, cmd *Command) { func writeFlag(buf io.StringWriter, flag *pflag.Flag, cmd *Command) {
name := flag.Name name := flag.Name
format := " flags+=(\"--%s" format := " flags+=(\"--%s"
if len(flag.NoOptDefVal) == 0 { if len(flag.NoOptDefVal) == 0 {
format += "=" format += "="
} }
format += "\")\n" format += cbn
buf.WriteString(fmt.Sprintf(format, name)) WrStringAndCheck(buf, fmt.Sprintf(format, name))
if len(flag.NoOptDefVal) == 0 { if len(flag.NoOptDefVal) == 0 {
format = " two_word_flags+=(\"--%s\")\n" format = " two_word_flags+=(\"--%s" + cbn
buf.WriteString(fmt.Sprintf(format, name)) WrStringAndCheck(buf, fmt.Sprintf(format, name))
} }
writeFlagHandler(buf, "--"+name, flag.Annotations, cmd) writeFlagHandler(buf, "--"+name, flag.Annotations, cmd)
} }
func writeLocalNonPersistentFlag(buf *bytes.Buffer, flag *pflag.Flag) { func writeLocalNonPersistentFlag(buf io.StringWriter, flag *pflag.Flag) {
name := flag.Name name := flag.Name
format := " local_nonpersistent_flags+=(\"--%s" format := " local_nonpersistent_flags+=(\"--%s"
if len(flag.NoOptDefVal) == 0 { if len(flag.NoOptDefVal) == 0 {
format += "=" format += "="
} }
format += "\")\n" format += cbn
buf.WriteString(fmt.Sprintf(format, name)) WrStringAndCheck(buf, fmt.Sprintf(format, name))
} }
func writeFlags(buf *bytes.Buffer, cmd *Command) { func writeFlags(buf io.StringWriter, cmd *Command) {
buf.WriteString(` flags=() WrStringAndCheck(buf, ` flags=()
two_word_flags=() two_word_flags=()
local_nonpersistent_flags=() local_nonpersistent_flags=()
flags_with_completion=() flags_with_completion=()
@ -435,11 +438,11 @@ func writeFlags(buf *bytes.Buffer, cmd *Command) {
} }
}) })
buf.WriteString("\n") WrStringAndCheck(buf, "\n")
} }
func writeRequiredFlag(buf *bytes.Buffer, cmd *Command) { func writeRequiredFlag(buf io.StringWriter, cmd *Command) {
buf.WriteString(" must_have_one_flag=()\n") WrStringAndCheck(buf, " must_have_one_flag=()\n")
flags := cmd.NonInheritedFlags() flags := cmd.NonInheritedFlags()
flags.VisitAll(func(flag *pflag.Flag) { flags.VisitAll(func(flag *pflag.Flag) {
if nonCompletableFlag(flag) { if nonCompletableFlag(flag) {
@ -452,49 +455,49 @@ func writeRequiredFlag(buf *bytes.Buffer, cmd *Command) {
if flag.Value.Type() != "bool" { if flag.Value.Type() != "bool" {
format += "=" format += "="
} }
format += "\")\n" format += cbn
buf.WriteString(fmt.Sprintf(format, flag.Name)) WrStringAndCheck(buf, fmt.Sprintf(format, flag.Name))
if len(flag.Shorthand) > 0 { if len(flag.Shorthand) > 0 {
buf.WriteString(fmt.Sprintf(" must_have_one_flag+=(\"-%s\")\n", flag.Shorthand)) WrStringAndCheck(buf, fmt.Sprintf(" must_have_one_flag+=(\"-%s"+cbn, flag.Shorthand))
} }
} }
} }
}) })
} }
func writeRequiredNouns(buf *bytes.Buffer, cmd *Command) { func writeRequiredNouns(buf io.StringWriter, cmd *Command) {
buf.WriteString(" must_have_one_noun=()\n") WrStringAndCheck(buf, " must_have_one_noun=()\n")
sort.Strings(cmd.ValidArgs) sort.Strings(cmd.ValidArgs)
for _, value := range cmd.ValidArgs { for _, value := range cmd.ValidArgs {
buf.WriteString(fmt.Sprintf(" must_have_one_noun+=(%q)\n", value)) WrStringAndCheck(buf, fmt.Sprintf(" must_have_one_noun+=(%q)\n", value))
} }
} }
func writeCmdAliases(buf *bytes.Buffer, cmd *Command) { func writeCmdAliases(buf io.StringWriter, cmd *Command) {
if len(cmd.Aliases) == 0 { if len(cmd.Aliases) == 0 {
return return
} }
sort.Strings(cmd.Aliases) sort.Strings(cmd.Aliases)
buf.WriteString(fmt.Sprint(` if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then`, "\n")) WrStringAndCheck(buf, fmt.Sprint(` if [[ -z "${BASH_VERSION}" || "${BASH_VERSINFO[0]}" -gt 3 ]]; then`, "\n"))
for _, value := range cmd.Aliases { for _, value := range cmd.Aliases {
buf.WriteString(fmt.Sprintf(" command_aliases+=(%q)\n", value)) WrStringAndCheck(buf, fmt.Sprintf(" command_aliases+=(%q)\n", value))
buf.WriteString(fmt.Sprintf(" aliashash[%q]=%q\n", value, cmd.Name())) WrStringAndCheck(buf, fmt.Sprintf(" aliashash[%q]=%q\n", value, cmd.Name()))
} }
buf.WriteString(` fi`) WrStringAndCheck(buf, ` fi`)
buf.WriteString("\n") WrStringAndCheck(buf, "\n")
} }
func writeArgAliases(buf *bytes.Buffer, cmd *Command) { func writeArgAliases(buf io.StringWriter, cmd *Command) {
buf.WriteString(" noun_aliases=()\n") WrStringAndCheck(buf, " noun_aliases=()\n")
sort.Strings(cmd.ArgAliases) sort.Strings(cmd.ArgAliases)
for _, value := range cmd.ArgAliases { for _, value := range cmd.ArgAliases {
buf.WriteString(fmt.Sprintf(" noun_aliases+=(%q)\n", value)) WrStringAndCheck(buf, fmt.Sprintf(" noun_aliases+=(%q)\n", value))
} }
} }
func gen(buf *bytes.Buffer, cmd *Command) { func gen(buf io.StringWriter, cmd *Command) {
for _, c := range cmd.Commands() { for _, c := range cmd.Commands() {
if !c.IsAvailableCommand() || c == cmd.helpCommand { if !c.IsAvailableCommand() || c == cmd.helpCommand {
continue continue
@ -506,22 +509,22 @@ func gen(buf *bytes.Buffer, cmd *Command) {
commandName = strings.Replace(commandName, ":", "__", -1) commandName = strings.Replace(commandName, ":", "__", -1)
if cmd.Root() == cmd { if cmd.Root() == cmd {
buf.WriteString(fmt.Sprintf("_%s_root_command()\n{\n", commandName)) WrStringAndCheck(buf, fmt.Sprintf("_%s_root_command()\n{\n", commandName))
} else { } else {
buf.WriteString(fmt.Sprintf("_%s()\n{\n", commandName)) WrStringAndCheck(buf, fmt.Sprintf("_%s()\n{\n", commandName))
} }
buf.WriteString(fmt.Sprintf(" last_command=%q\n", commandName)) WrStringAndCheck(buf, fmt.Sprintf(" last_command=%q\n", commandName))
buf.WriteString("\n") WrStringAndCheck(buf, "\n")
buf.WriteString(" command_aliases=()\n") WrStringAndCheck(buf, " command_aliases=()\n")
buf.WriteString("\n") WrStringAndCheck(buf, "\n")
writeCommands(buf, cmd) writeCommands(buf, cmd)
writeFlags(buf, cmd) writeFlags(buf, cmd)
writeRequiredFlag(buf, cmd) writeRequiredFlag(buf, cmd)
writeRequiredNouns(buf, cmd) writeRequiredNouns(buf, cmd)
writeArgAliases(buf, cmd) writeArgAliases(buf, cmd)
buf.WriteString("}\n\n") WrStringAndCheck(buf, "}\n\n")
} }
// GenBashCompletion generates bash completion file and writes to the passed writer. // GenBashCompletion generates bash completion file and writes to the passed writer.

14
command_test.go
View file

@ -676,9 +676,9 @@ func TestPersistentFlagsOnChild(t *testing.T) {
func TestRequiredFlags(t *testing.T) { func TestRequiredFlags(t *testing.T) {
c := &Command{Use: "c", Run: emptyRun} c := &Command{Use: "c", Run: emptyRun}
c.Flags().String("foo1", "", "") c.Flags().String("foo1", "", "")
c.MarkFlagRequired("foo1") er(c.MarkFlagRequired("foo1"))
c.Flags().String("foo2", "", "") c.Flags().String("foo2", "", "")
c.MarkFlagRequired("foo2") er(c.MarkFlagRequired("foo2"))
c.Flags().String("bar", "", "") c.Flags().String("bar", "", "")
expected := fmt.Sprintf("required flag(s) %q, %q not set", "foo1", "foo2") expected := fmt.Sprintf("required flag(s) %q, %q not set", "foo1", "foo2")
@ -694,16 +694,16 @@ func TestRequiredFlags(t *testing.T) {
func TestPersistentRequiredFlags(t *testing.T) { func TestPersistentRequiredFlags(t *testing.T) {
parent := &Command{Use: "parent", Run: emptyRun} parent := &Command{Use: "parent", Run: emptyRun}
parent.PersistentFlags().String("foo1", "", "") parent.PersistentFlags().String("foo1", "", "")
parent.MarkPersistentFlagRequired("foo1") er(parent.MarkPersistentFlagRequired("foo1"))
parent.PersistentFlags().String("foo2", "", "") parent.PersistentFlags().String("foo2", "", "")
parent.MarkPersistentFlagRequired("foo2") er(parent.MarkPersistentFlagRequired("foo2"))
parent.Flags().String("foo3", "", "") parent.Flags().String("foo3", "", "")
child := &Command{Use: "child", Run: emptyRun} child := &Command{Use: "child", Run: emptyRun}
child.Flags().String("bar1", "", "") child.Flags().String("bar1", "", "")
child.MarkFlagRequired("bar1") er(child.MarkFlagRequired("bar1"))
child.Flags().String("bar2", "", "") child.Flags().String("bar2", "", "")
child.MarkFlagRequired("bar2") er(child.MarkFlagRequired("bar2"))
child.Flags().String("bar3", "", "") child.Flags().String("bar3", "", "")
parent.AddCommand(child) parent.AddCommand(child)
@ -1484,7 +1484,7 @@ func TestMergeCommandLineToFlags(t *testing.T) {
func TestUseDeprecatedFlags(t *testing.T) { func TestUseDeprecatedFlags(t *testing.T) {
c := &Command{Use: "c", Run: emptyRun} c := &Command{Use: "c", Run: emptyRun}
c.Flags().BoolP("deprecated", "d", false, "deprecated flag") c.Flags().BoolP("deprecated", "d", false, "deprecated flag")
c.Flags().MarkDeprecated("deprecated", "This flag is deprecated") er(c.Flags().MarkDeprecated("deprecated", "This flag is deprecated"))
output, err := executeCommand(c, "c", "-d") output, err := executeCommand(c, "c", "-d")
if err != nil { if err != nil {