1// Copyright © 2013 Steve Francia <spf@spf13.com>.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6// http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13
14// Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces.
15// In addition to providing an interface, Cobra simultaneously provides a controller to organize your application code.
16package cobra
17
18import (
19 "bytes"
20 "fmt"
21 "io"
22 "os"
23 "path/filepath"
24 "sort"
25 "strings"
26
27 flag "github.com/spf13/pflag"
28)
29
30// FParseErrWhitelist configures Flag parse errors to be ignored
31type FParseErrWhitelist flag.ParseErrorsWhitelist
32
33// Command is just that, a command for your application.
34// E.g. 'go run ...' - 'run' is the command. Cobra requires
35// you to define the usage and description as part of your command
36// definition to ensure usability.
37type Command struct {
38 // Use is the one-line usage message.
39 Use string
40
41 // Aliases is an array of aliases that can be used instead of the first word in Use.
42 Aliases []string
43
44 // SuggestFor is an array of command names for which this command will be suggested -
45 // similar to aliases but only suggests.
46 SuggestFor []string
47
48 // Short is the short description shown in the 'help' output.
49 Short string
50
51 // Long is the long message shown in the 'help <this-command>' output.
52 Long string
53
54 // Example is examples of how to use the command.
55 Example string
56
57 // ValidArgs is list of all valid non-flag arguments that are accepted in bash completions
58 ValidArgs []string
59
60 // Expected arguments
61 Args PositionalArgs
62
63 // ArgAliases is List of aliases for ValidArgs.
64 // These are not suggested to the user in the bash completion,
65 // but accepted if entered manually.
66 ArgAliases []string
67
68 // BashCompletionFunction is custom functions used by the bash autocompletion generator.
69 BashCompletionFunction string
70
71 // Deprecated defines, if this command is deprecated and should print this string when used.
72 Deprecated string
73
74 // Hidden defines, if this command is hidden and should NOT show up in the list of available commands.
75 Hidden bool
76
77 // Annotations are key/value pairs that can be used by applications to identify or
78 // group commands.
79 Annotations map[string]string
80
81 // Version defines the version for this command. If this value is non-empty and the command does not
82 // define a "version" flag, a "version" boolean flag will be added to the command and, if specified,
83 // will print content of the "Version" variable.
84 Version string
85
86 // The *Run functions are executed in the following order:
87 // * PersistentPreRun()
88 // * PreRun()
89 // * Run()
90 // * PostRun()
91 // * PersistentPostRun()
92 // All functions get the same args, the arguments after the command name.
93 //
94 // PersistentPreRun: children of this command will inherit and execute.
95 PersistentPreRun func(cmd *Command, args []string)
96 // PersistentPreRunE: PersistentPreRun but returns an error.
97 PersistentPreRunE func(cmd *Command, args []string) error
98 // PreRun: children of this command will not inherit.
99 PreRun func(cmd *Command, args []string)
100 // PreRunE: PreRun but returns an error.
101 PreRunE func(cmd *Command, args []string) error
102 // Run: Typically the actual work function. Most commands will only implement this.
103 Run func(cmd *Command, args []string)
104 // RunE: Run but returns an error.
105 RunE func(cmd *Command, args []string) error
106 // PostRun: run after the Run command.
107 PostRun func(cmd *Command, args []string)
108 // PostRunE: PostRun but returns an error.
109 PostRunE func(cmd *Command, args []string) error
110 // PersistentPostRun: children of this command will inherit and execute after PostRun.
111 PersistentPostRun func(cmd *Command, args []string)
112 // PersistentPostRunE: PersistentPostRun but returns an error.
113 PersistentPostRunE func(cmd *Command, args []string) error
114
115 // SilenceErrors is an option to quiet errors down stream.
116 SilenceErrors bool
117
118 // SilenceUsage is an option to silence usage when an error occurs.
119 SilenceUsage bool
120
121 // DisableFlagParsing disables the flag parsing.
122 // If this is true all flags will be passed to the command as arguments.
123 DisableFlagParsing bool
124
125 // DisableAutoGenTag defines, if gen tag ("Auto generated by spf13/cobra...")
126 // will be printed by generating docs for this command.
127 DisableAutoGenTag bool
128
129 // DisableFlagsInUseLine will disable the addition of [flags] to the usage
130 // line of a command when printing help or generating docs
131 DisableFlagsInUseLine bool
132
133 // DisableSuggestions disables the suggestions based on Levenshtein distance
134 // that go along with 'unknown command' messages.
135 DisableSuggestions bool
136 // SuggestionsMinimumDistance defines minimum levenshtein distance to display suggestions.
137 // Must be > 0.
138 SuggestionsMinimumDistance int
139
140 // TraverseChildren parses flags on all parents before executing child command.
141 TraverseChildren bool
142
143 //FParseErrWhitelist flag parse errors to be ignored
144 FParseErrWhitelist FParseErrWhitelist
145
146 // commands is the list of commands supported by this program.
147 commands []*Command
148 // parent is a parent command for this command.
149 parent *Command
150 // Max lengths of commands' string lengths for use in padding.
151 commandsMaxUseLen int
152 commandsMaxCommandPathLen int
153 commandsMaxNameLen int
154 // commandsAreSorted defines, if command slice are sorted or not.
155 commandsAreSorted bool
156 // commandCalledAs is the name or alias value used to call this command.
157 commandCalledAs struct {
158 name string
159 called bool
160 }
161
162 // args is actual args parsed from flags.
163 args []string
164 // flagErrorBuf contains all error messages from pflag.
165 flagErrorBuf *bytes.Buffer
166 // flags is full set of flags.
167 flags *flag.FlagSet
168 // pflags contains persistent flags.
169 pflags *flag.FlagSet
170 // lflags contains local flags.
171 lflags *flag.FlagSet
172 // iflags contains inherited flags.
173 iflags *flag.FlagSet
174 // parentsPflags is all persistent flags of cmd's parents.
175 parentsPflags *flag.FlagSet
176 // globNormFunc is the global normalization function
177 // that we can use on every pflag set and children commands
178 globNormFunc func(f *flag.FlagSet, name string) flag.NormalizedName
179
180 // output is an output writer defined by user.
181 output io.Writer
182 // usageFunc is usage func defined by user.
183 usageFunc func(*Command) error
184 // usageTemplate is usage template defined by user.
185 usageTemplate string
186 // flagErrorFunc is func defined by user and it's called when the parsing of
187 // flags returns an error.
188 flagErrorFunc func(*Command, error) error
189 // helpTemplate is help template defined by user.
190 helpTemplate string
191 // helpFunc is help func defined by user.
192 helpFunc func(*Command, []string)
193 // helpCommand is command with usage 'help'. If it's not defined by user,
194 // cobra uses default help command.
195 helpCommand *Command
196 // versionTemplate is the version template defined by user.
197 versionTemplate string
198}
199
200// SetArgs sets arguments for the command. It is set to os.Args[1:] by default, if desired, can be overridden
201// particularly useful when testing.
202func (c *Command) SetArgs(a []string) {
203 c.args = a
204}
205
206// SetOutput sets the destination for usage and error messages.
207// If output is nil, os.Stderr is used.
208func (c *Command) SetOutput(output io.Writer) {
209 c.output = output
210}
211
212// SetUsageFunc sets usage function. Usage can be defined by application.
213func (c *Command) SetUsageFunc(f func(*Command) error) {
214 c.usageFunc = f
215}
216
217// SetUsageTemplate sets usage template. Can be defined by Application.
218func (c *Command) SetUsageTemplate(s string) {
219 c.usageTemplate = s
220}
221
222// SetFlagErrorFunc sets a function to generate an error when flag parsing
223// fails.
224func (c *Command) SetFlagErrorFunc(f func(*Command, error) error) {
225 c.flagErrorFunc = f
226}
227
228// SetHelpFunc sets help function. Can be defined by Application.
229func (c *Command) SetHelpFunc(f func(*Command, []string)) {
230 c.helpFunc = f
231}
232
233// SetHelpCommand sets help command.
234func (c *Command) SetHelpCommand(cmd *Command) {
235 c.helpCommand = cmd
236}
237
238// SetHelpTemplate sets help template to be used. Application can use it to set custom template.
239func (c *Command) SetHelpTemplate(s string) {
240 c.helpTemplate = s
241}
242
243// SetVersionTemplate sets version template to be used. Application can use it to set custom template.
244func (c *Command) SetVersionTemplate(s string) {
245 c.versionTemplate = s
246}
247
248// SetGlobalNormalizationFunc sets a normalization function to all flag sets and also to child commands.
249// The user should not have a cyclic dependency on commands.
250func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string) flag.NormalizedName) {
251 c.Flags().SetNormalizeFunc(n)
252 c.PersistentFlags().SetNormalizeFunc(n)
253 c.globNormFunc = n
254
255 for _, command := range c.commands {
256 command.SetGlobalNormalizationFunc(n)
257 }
258}
259
260// OutOrStdout returns output to stdout.
261func (c *Command) OutOrStdout() io.Writer {
262 return c.getOut(os.Stdout)
263}
264
265// OutOrStderr returns output to stderr
266func (c *Command) OutOrStderr() io.Writer {
267 return c.getOut(os.Stderr)
268}
269
270func (c *Command) getOut(def io.Writer) io.Writer {
271 if c.output != nil {
272 return c.output
273 }
274 if c.HasParent() {
275 return c.parent.getOut(def)
276 }
277 return def
278}
279
280// UsageFunc returns either the function set by SetUsageFunc for this command
281// or a parent, or it returns a default usage function.
282func (c *Command) UsageFunc() (f func(*Command) error) {
283 if c.usageFunc != nil {
284 return c.usageFunc
285 }
286 if c.HasParent() {
287 return c.Parent().UsageFunc()
288 }
289 return func(c *Command) error {
290 c.mergePersistentFlags()
291 err := tmpl(c.OutOrStderr(), c.UsageTemplate(), c)
292 if err != nil {
293 c.Println(err)
294 }
295 return err
296 }
297}
298
299// Usage puts out the usage for the command.
300// Used when a user provides invalid input.
301// Can be defined by user by overriding UsageFunc.
302func (c *Command) Usage() error {
303 return c.UsageFunc()(c)
304}
305
306// HelpFunc returns either the function set by SetHelpFunc for this command
307// or a parent, or it returns a function with default help behavior.
308func (c *Command) HelpFunc() func(*Command, []string) {
309 if c.helpFunc != nil {
310 return c.helpFunc
311 }
312 if c.HasParent() {
313 return c.Parent().HelpFunc()
314 }
315 return func(c *Command, a []string) {
316 c.mergePersistentFlags()
317 err := tmpl(c.OutOrStdout(), c.HelpTemplate(), c)
318 if err != nil {
319 c.Println(err)
320 }
321 }
322}
323
324// Help puts out the help for the command.
325// Used when a user calls help [command].
326// Can be defined by user by overriding HelpFunc.
327func (c *Command) Help() error {
328 c.HelpFunc()(c, []string{})
329 return nil
330}
331
332// UsageString return usage string.
333func (c *Command) UsageString() string {
334 tmpOutput := c.output
335 bb := new(bytes.Buffer)
336 c.SetOutput(bb)
337 c.Usage()
338 c.output = tmpOutput
339 return bb.String()
340}
341
342// FlagErrorFunc returns either the function set by SetFlagErrorFunc for this
343// command or a parent, or it returns a function which returns the original
344// error.
345func (c *Command) FlagErrorFunc() (f func(*Command, error) error) {
346 if c.flagErrorFunc != nil {
347 return c.flagErrorFunc
348 }
349
350 if c.HasParent() {
351 return c.parent.FlagErrorFunc()
352 }
353 return func(c *Command, err error) error {
354 return err
355 }
356}
357
358var minUsagePadding = 25
359
360// UsagePadding return padding for the usage.
361func (c *Command) UsagePadding() int {
362 if c.parent == nil || minUsagePadding > c.parent.commandsMaxUseLen {
363 return minUsagePadding
364 }
365 return c.parent.commandsMaxUseLen
366}
367
368var minCommandPathPadding = 11
369
370// CommandPathPadding return padding for the command path.
371func (c *Command) CommandPathPadding() int {
372 if c.parent == nil || minCommandPathPadding > c.parent.commandsMaxCommandPathLen {
373 return minCommandPathPadding
374 }
375 return c.parent.commandsMaxCommandPathLen
376}
377
378var minNamePadding = 11
379
380// NamePadding returns padding for the name.
381func (c *Command) NamePadding() int {
382 if c.parent == nil || minNamePadding > c.parent.commandsMaxNameLen {
383 return minNamePadding
384 }
385 return c.parent.commandsMaxNameLen
386}
387
388// UsageTemplate returns usage template for the command.
389func (c *Command) UsageTemplate() string {
390 if c.usageTemplate != "" {
391 return c.usageTemplate
392 }
393
394 if c.HasParent() {
395 return c.parent.UsageTemplate()
396 }
397 return `Usage:{{if .Runnable}}
398 {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}}
399 {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}}
400
401Aliases:
402 {{.NameAndAliases}}{{end}}{{if .HasExample}}
403
404Examples:
405{{.Example}}{{end}}{{if .HasAvailableSubCommands}}
406
407Available Commands:{{range .Commands}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
408 {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
409
410Flags:
411{{.LocalFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasAvailableInheritedFlags}}
412
413Global Flags:
414{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
415
416Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
417 {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
418
419Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
420`
421}
422
423// HelpTemplate return help template for the command.
424func (c *Command) HelpTemplate() string {
425 if c.helpTemplate != "" {
426 return c.helpTemplate
427 }
428
429 if c.HasParent() {
430 return c.parent.HelpTemplate()
431 }
432 return `{{with (or .Long .Short)}}{{. | trimTrailingWhitespaces}}
433
434{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}`
435}
436
437// VersionTemplate return version template for the command.
438func (c *Command) VersionTemplate() string {
439 if c.versionTemplate != "" {
440 return c.versionTemplate
441 }
442
443 if c.HasParent() {
444 return c.parent.VersionTemplate()
445 }
446 return `{{with .Name}}{{printf "%s " .}}{{end}}{{printf "version %s" .Version}}
447`
448}
449
450func hasNoOptDefVal(name string, fs *flag.FlagSet) bool {
451 flag := fs.Lookup(name)
452 if flag == nil {
453 return false
454 }
455 return flag.NoOptDefVal != ""
456}
457
458func shortHasNoOptDefVal(name string, fs *flag.FlagSet) bool {
459 if len(name) == 0 {
460 return false
461 }
462
463 flag := fs.ShorthandLookup(name[:1])
464 if flag == nil {
465 return false
466 }
467 return flag.NoOptDefVal != ""
468}
469
470func stripFlags(args []string, c *Command) []string {
471 if len(args) == 0 {
472 return args
473 }
474 c.mergePersistentFlags()
475
476 commands := []string{}
477 flags := c.Flags()
478
479Loop:
480 for len(args) > 0 {
481 s := args[0]
482 args = args[1:]
483 switch {
484 case s == "--":
485 // "--" terminates the flags
486 break Loop
487 case strings.HasPrefix(s, "--") && !strings.Contains(s, "=") && !hasNoOptDefVal(s[2:], flags):
488 // If '--flag arg' then
489 // delete arg from args.
490 fallthrough // (do the same as below)
491 case strings.HasPrefix(s, "-") && !strings.Contains(s, "=") && len(s) == 2 && !shortHasNoOptDefVal(s[1:], flags):
492 // If '-f arg' then
493 // delete 'arg' from args or break the loop if len(args) <= 1.
494 if len(args) <= 1 {
495 break Loop
496 } else {
497 args = args[1:]
498 continue
499 }
500 case s != "" && !strings.HasPrefix(s, "-"):
501 commands = append(commands, s)
502 }
503 }
504
505 return commands
506}
507
508// argsMinusFirstX removes only the first x from args. Otherwise, commands that look like
509// openshift admin policy add-role-to-user admin my-user, lose the admin argument (arg[4]).
510func argsMinusFirstX(args []string, x string) []string {
511 for i, y := range args {
512 if x == y {
513 ret := []string{}
514 ret = append(ret, args[:i]...)
515 ret = append(ret, args[i+1:]...)
516 return ret
517 }
518 }
519 return args
520}
521
522func isFlagArg(arg string) bool {
523 return ((len(arg) >= 3 && arg[1] == '-') ||
524 (len(arg) >= 2 && arg[0] == '-' && arg[1] != '-'))
525}
526
527// Find the target command given the args and command tree
528// Meant to be run on the highest node. Only searches down.
529func (c *Command) Find(args []string) (*Command, []string, error) {
530 var innerfind func(*Command, []string) (*Command, []string)
531
532 innerfind = func(c *Command, innerArgs []string) (*Command, []string) {
533 argsWOflags := stripFlags(innerArgs, c)
534 if len(argsWOflags) == 0 {
535 return c, innerArgs
536 }
537 nextSubCmd := argsWOflags[0]
538
539 cmd := c.findNext(nextSubCmd)
540 if cmd != nil {
541 return innerfind(cmd, argsMinusFirstX(innerArgs, nextSubCmd))
542 }
543 return c, innerArgs
544 }
545
546 commandFound, a := innerfind(c, args)
547 if commandFound.Args == nil {
548 return commandFound, a, legacyArgs(commandFound, stripFlags(a, commandFound))
549 }
550 return commandFound, a, nil
551}
552
553func (c *Command) findSuggestions(arg string) string {
554 if c.DisableSuggestions {
555 return ""
556 }
557 if c.SuggestionsMinimumDistance <= 0 {
558 c.SuggestionsMinimumDistance = 2
559 }
560 suggestionsString := ""
561 if suggestions := c.SuggestionsFor(arg); len(suggestions) > 0 {
562 suggestionsString += "\n\nDid you mean this?\n"
563 for _, s := range suggestions {
564 suggestionsString += fmt.Sprintf("\t%v\n", s)
565 }
566 }
567 return suggestionsString
568}
569
570func (c *Command) findNext(next string) *Command {
571 matches := make([]*Command, 0)
572 for _, cmd := range c.commands {
573 if cmd.Name() == next || cmd.HasAlias(next) {
574 cmd.commandCalledAs.name = next
575 return cmd
576 }
577 if EnablePrefixMatching && cmd.hasNameOrAliasPrefix(next) {
578 matches = append(matches, cmd)
579 }
580 }
581
582 if len(matches) == 1 {
583 return matches[0]
584 }
585
586 return nil
587}
588
589// Traverse the command tree to find the command, and parse args for
590// each parent.
591func (c *Command) Traverse(args []string) (*Command, []string, error) {
592 flags := []string{}
593 inFlag := false
594
595 for i, arg := range args {
596 switch {
597 // A long flag with a space separated value
598 case strings.HasPrefix(arg, "--") && !strings.Contains(arg, "="):
599 // TODO: this isn't quite right, we should really check ahead for 'true' or 'false'
600 inFlag = !hasNoOptDefVal(arg[2:], c.Flags())
601 flags = append(flags, arg)
602 continue
603 // A short flag with a space separated value
604 case strings.HasPrefix(arg, "-") && !strings.Contains(arg, "=") && len(arg) == 2 && !shortHasNoOptDefVal(arg[1:], c.Flags()):
605 inFlag = true
606 flags = append(flags, arg)
607 continue
608 // The value for a flag
609 case inFlag:
610 inFlag = false
611 flags = append(flags, arg)
612 continue
613 // A flag without a value, or with an `=` separated value
614 case isFlagArg(arg):
615 flags = append(flags, arg)
616 continue
617 }
618
619 cmd := c.findNext(arg)
620 if cmd == nil {
621 return c, args, nil
622 }
623
624 if err := c.ParseFlags(flags); err != nil {
625 return nil, args, err
626 }
627 return cmd.Traverse(args[i+1:])
628 }
629 return c, args, nil
630}
631
632// SuggestionsFor provides suggestions for the typedName.
633func (c *Command) SuggestionsFor(typedName string) []string {
634 suggestions := []string{}
635 for _, cmd := range c.commands {
636 if cmd.IsAvailableCommand() {
637 levenshteinDistance := ld(typedName, cmd.Name(), true)
638 suggestByLevenshtein := levenshteinDistance <= c.SuggestionsMinimumDistance
639 suggestByPrefix := strings.HasPrefix(strings.ToLower(cmd.Name()), strings.ToLower(typedName))
640 if suggestByLevenshtein || suggestByPrefix {
641 suggestions = append(suggestions, cmd.Name())
642 }
643 for _, explicitSuggestion := range cmd.SuggestFor {
644 if strings.EqualFold(typedName, explicitSuggestion) {
645 suggestions = append(suggestions, cmd.Name())
646 }
647 }
648 }
649 }
650 return suggestions
651}
652
653// VisitParents visits all parents of the command and invokes fn on each parent.
654func (c *Command) VisitParents(fn func(*Command)) {
655 if c.HasParent() {
656 fn(c.Parent())
657 c.Parent().VisitParents(fn)
658 }
659}
660
661// Root finds root command.
662func (c *Command) Root() *Command {
663 if c.HasParent() {
664 return c.Parent().Root()
665 }
666 return c
667}
668
669// ArgsLenAtDash will return the length of c.Flags().Args at the moment
670// when a -- was found during args parsing.
671func (c *Command) ArgsLenAtDash() int {
672 return c.Flags().ArgsLenAtDash()
673}
674
675func (c *Command) execute(a []string) (err error) {
676 if c == nil {
677 return fmt.Errorf("Called Execute() on a nil Command")
678 }
679
680 if len(c.Deprecated) > 0 {
681 c.Printf("Command %q is deprecated, %s\n", c.Name(), c.Deprecated)
682 }
683
684 // initialize help and version flag at the last point possible to allow for user
685 // overriding
686 c.InitDefaultHelpFlag()
687 c.InitDefaultVersionFlag()
688
689 err = c.ParseFlags(a)
690 if err != nil {
691 return c.FlagErrorFunc()(c, err)
692 }
693
694 // If help is called, regardless of other flags, return we want help.
695 // Also say we need help if the command isn't runnable.
696 helpVal, err := c.Flags().GetBool("help")
697 if err != nil {
698 // should be impossible to get here as we always declare a help
699 // flag in InitDefaultHelpFlag()
700 c.Println("\"help\" flag declared as non-bool. Please correct your code")
701 return err
702 }
703
704 if helpVal {
705 return flag.ErrHelp
706 }
707
708 // for back-compat, only add version flag behavior if version is defined
709 if c.Version != "" {
710 versionVal, err := c.Flags().GetBool("version")
711 if err != nil {
712 c.Println("\"version\" flag declared as non-bool. Please correct your code")
713 return err
714 }
715 if versionVal {
716 err := tmpl(c.OutOrStdout(), c.VersionTemplate(), c)
717 if err != nil {
718 c.Println(err)
719 }
720 return err
721 }
722 }
723
724 if !c.Runnable() {
725 return flag.ErrHelp
726 }
727
728 c.preRun()
729
730 argWoFlags := c.Flags().Args()
731 if c.DisableFlagParsing {
732 argWoFlags = a
733 }
734
735 if err := c.ValidateArgs(argWoFlags); err != nil {
736 return err
737 }
738
739 for p := c; p != nil; p = p.Parent() {
740 if p.PersistentPreRunE != nil {
741 if err := p.PersistentPreRunE(c, argWoFlags); err != nil {
742 return err
743 }
744 break
745 } else if p.PersistentPreRun != nil {
746 p.PersistentPreRun(c, argWoFlags)
747 break
748 }
749 }
750 if c.PreRunE != nil {
751 if err := c.PreRunE(c, argWoFlags); err != nil {
752 return err
753 }
754 } else if c.PreRun != nil {
755 c.PreRun(c, argWoFlags)
756 }
757
758 if err := c.validateRequiredFlags(); err != nil {
759 return err
760 }
761 if c.RunE != nil {
762 if err := c.RunE(c, argWoFlags); err != nil {
763 return err
764 }
765 } else {
766 c.Run(c, argWoFlags)
767 }
768 if c.PostRunE != nil {
769 if err := c.PostRunE(c, argWoFlags); err != nil {
770 return err
771 }
772 } else if c.PostRun != nil {
773 c.PostRun(c, argWoFlags)
774 }
775 for p := c; p != nil; p = p.Parent() {
776 if p.PersistentPostRunE != nil {
777 if err := p.PersistentPostRunE(c, argWoFlags); err != nil {
778 return err
779 }
780 break
781 } else if p.PersistentPostRun != nil {
782 p.PersistentPostRun(c, argWoFlags)
783 break
784 }
785 }
786
787 return nil
788}
789
790func (c *Command) preRun() {
791 for _, x := range initializers {
792 x()
793 }
794}
795
796// Execute uses the args (os.Args[1:] by default)
797// and run through the command tree finding appropriate matches
798// for commands and then corresponding flags.
799func (c *Command) Execute() error {
800 _, err := c.ExecuteC()
801 return err
802}
803
804// ExecuteC executes the command.
805func (c *Command) ExecuteC() (cmd *Command, err error) {
806 // Regardless of what command execute is called on, run on Root only
807 if c.HasParent() {
808 return c.Root().ExecuteC()
809 }
810
811 // windows hook
812 if preExecHookFn != nil {
813 preExecHookFn(c)
814 }
815
816 // initialize help as the last point possible to allow for user
817 // overriding
818 c.InitDefaultHelpCmd()
819
820 var args []string
821
822 // Workaround FAIL with "go test -v" or "cobra.test -test.v", see #155
823 if c.args == nil && filepath.Base(os.Args[0]) != "cobra.test" {
824 args = os.Args[1:]
825 } else {
826 args = c.args
827 }
828
829 var flags []string
830 if c.TraverseChildren {
831 cmd, flags, err = c.Traverse(args)
832 } else {
833 cmd, flags, err = c.Find(args)
834 }
835 if err != nil {
836 // If found parse to a subcommand and then failed, talk about the subcommand
837 if cmd != nil {
838 c = cmd
839 }
840 if !c.SilenceErrors {
841 c.Println("Error:", err.Error())
842 c.Printf("Run '%v --help' for usage.\n", c.CommandPath())
843 }
844 return c, err
845 }
846
847 cmd.commandCalledAs.called = true
848 if cmd.commandCalledAs.name == "" {
849 cmd.commandCalledAs.name = cmd.Name()
850 }
851
852 err = cmd.execute(flags)
853 if err != nil {
854 // Always show help if requested, even if SilenceErrors is in
855 // effect
856 if err == flag.ErrHelp {
857 cmd.HelpFunc()(cmd, args)
858 return cmd, nil
859 }
860
861 // If root command has SilentErrors flagged,
862 // all subcommands should respect it
863 if !cmd.SilenceErrors && !c.SilenceErrors {
864 c.Println("Error:", err.Error())
865 }
866
867 // If root command has SilentUsage flagged,
868 // all subcommands should respect it
869 if !cmd.SilenceUsage && !c.SilenceUsage {
870 c.Println(cmd.UsageString())
871 }
872 }
873 return cmd, err
874}
875
876func (c *Command) ValidateArgs(args []string) error {
877 if c.Args == nil {
878 return nil
879 }
880 return c.Args(c, args)
881}
882
883func (c *Command) validateRequiredFlags() error {
884 flags := c.Flags()
885 missingFlagNames := []string{}
886 flags.VisitAll(func(pflag *flag.Flag) {
887 requiredAnnotation, found := pflag.Annotations[BashCompOneRequiredFlag]
888 if !found {
889 return
890 }
891 if (requiredAnnotation[0] == "true") && !pflag.Changed {
892 missingFlagNames = append(missingFlagNames, pflag.Name)
893 }
894 })
895
896 if len(missingFlagNames) > 0 {
897 return fmt.Errorf(`required flag(s) "%s" not set`, strings.Join(missingFlagNames, `", "`))
898 }
899 return nil
900}
901
902// InitDefaultHelpFlag adds default help flag to c.
903// It is called automatically by executing the c or by calling help and usage.
904// If c already has help flag, it will do nothing.
905func (c *Command) InitDefaultHelpFlag() {
906 c.mergePersistentFlags()
907 if c.Flags().Lookup("help") == nil {
908 usage := "help for "
909 if c.Name() == "" {
910 usage += "this command"
911 } else {
912 usage += c.Name()
913 }
914 c.Flags().BoolP("help", "h", false, usage)
915 }
916}
917
918// InitDefaultVersionFlag adds default version flag to c.
919// It is called automatically by executing the c.
920// If c already has a version flag, it will do nothing.
921// If c.Version is empty, it will do nothing.
922func (c *Command) InitDefaultVersionFlag() {
923 if c.Version == "" {
924 return
925 }
926
927 c.mergePersistentFlags()
928 if c.Flags().Lookup("version") == nil {
929 usage := "version for "
930 if c.Name() == "" {
931 usage += "this command"
932 } else {
933 usage += c.Name()
934 }
935 c.Flags().Bool("version", false, usage)
936 }
937}
938
939// InitDefaultHelpCmd adds default help command to c.
940// It is called automatically by executing the c or by calling help and usage.
941// If c already has help command or c has no subcommands, it will do nothing.
942func (c *Command) InitDefaultHelpCmd() {
943 if !c.HasSubCommands() {
944 return
945 }
946
947 if c.helpCommand == nil {
948 c.helpCommand = &Command{
949 Use: "help [command]",
950 Short: "Help about any command",
951 Long: `Help provides help for any command in the application.
952Simply type ` + c.Name() + ` help [path to command] for full details.`,
953
954 Run: func(c *Command, args []string) {
955 cmd, _, e := c.Root().Find(args)
956 if cmd == nil || e != nil {
957 c.Printf("Unknown help topic %#q\n", args)
958 c.Root().Usage()
959 } else {
960 cmd.InitDefaultHelpFlag() // make possible 'help' flag to be shown
961 cmd.Help()
962 }
963 },
964 }
965 }
966 c.RemoveCommand(c.helpCommand)
967 c.AddCommand(c.helpCommand)
968}
969
970// ResetCommands delete parent, subcommand and help command from c.
971func (c *Command) ResetCommands() {
972 c.parent = nil
973 c.commands = nil
974 c.helpCommand = nil
975 c.parentsPflags = nil
976}
977
978// Sorts commands by their names.
979type commandSorterByName []*Command
980
981func (c commandSorterByName) Len() int { return len(c) }
982func (c commandSorterByName) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
983func (c commandSorterByName) Less(i, j int) bool { return c[i].Name() < c[j].Name() }
984
985// Commands returns a sorted slice of child commands.
986func (c *Command) Commands() []*Command {
987 // do not sort commands if it already sorted or sorting was disabled
988 if EnableCommandSorting && !c.commandsAreSorted {
989 sort.Sort(commandSorterByName(c.commands))
990 c.commandsAreSorted = true
991 }
992 return c.commands
993}
994
995// AddCommand adds one or more commands to this parent command.
996func (c *Command) AddCommand(cmds ...*Command) {
997 for i, x := range cmds {
998 if cmds[i] == c {
999 panic("Command can't be a child of itself")
1000 }
1001 cmds[i].parent = c
1002 // update max lengths
1003 usageLen := len(x.Use)
1004 if usageLen > c.commandsMaxUseLen {
1005 c.commandsMaxUseLen = usageLen
1006 }
1007 commandPathLen := len(x.CommandPath())
1008 if commandPathLen > c.commandsMaxCommandPathLen {
1009 c.commandsMaxCommandPathLen = commandPathLen
1010 }
1011 nameLen := len(x.Name())
1012 if nameLen > c.commandsMaxNameLen {
1013 c.commandsMaxNameLen = nameLen
1014 }
1015 // If global normalization function exists, update all children
1016 if c.globNormFunc != nil {
1017 x.SetGlobalNormalizationFunc(c.globNormFunc)
1018 }
1019 c.commands = append(c.commands, x)
1020 c.commandsAreSorted = false
1021 }
1022}
1023
1024// RemoveCommand removes one or more commands from a parent command.
1025func (c *Command) RemoveCommand(cmds ...*Command) {
1026 commands := []*Command{}
1027main:
1028 for _, command := range c.commands {
1029 for _, cmd := range cmds {
1030 if command == cmd {
1031 command.parent = nil
1032 continue main
1033 }
1034 }
1035 commands = append(commands, command)
1036 }
1037 c.commands = commands
1038 // recompute all lengths
1039 c.commandsMaxUseLen = 0
1040 c.commandsMaxCommandPathLen = 0
1041 c.commandsMaxNameLen = 0
1042 for _, command := range c.commands {
1043 usageLen := len(command.Use)
1044 if usageLen > c.commandsMaxUseLen {
1045 c.commandsMaxUseLen = usageLen
1046 }
1047 commandPathLen := len(command.CommandPath())
1048 if commandPathLen > c.commandsMaxCommandPathLen {
1049 c.commandsMaxCommandPathLen = commandPathLen
1050 }
1051 nameLen := len(command.Name())
1052 if nameLen > c.commandsMaxNameLen {
1053 c.commandsMaxNameLen = nameLen
1054 }
1055 }
1056}
1057
1058// Print is a convenience method to Print to the defined output, fallback to Stderr if not set.
1059func (c *Command) Print(i ...interface{}) {
1060 fmt.Fprint(c.OutOrStderr(), i...)
1061}
1062
1063// Println is a convenience method to Println to the defined output, fallback to Stderr if not set.
1064func (c *Command) Println(i ...interface{}) {
1065 c.Print(fmt.Sprintln(i...))
1066}
1067
1068// Printf is a convenience method to Printf to the defined output, fallback to Stderr if not set.
1069func (c *Command) Printf(format string, i ...interface{}) {
1070 c.Print(fmt.Sprintf(format, i...))
1071}
1072
1073// CommandPath returns the full path to this command.
1074func (c *Command) CommandPath() string {
1075 if c.HasParent() {
1076 return c.Parent().CommandPath() + " " + c.Name()
1077 }
1078 return c.Name()
1079}
1080
1081// UseLine puts out the full usage for a given command (including parents).
1082func (c *Command) UseLine() string {
1083 var useline string
1084 if c.HasParent() {
1085 useline = c.parent.CommandPath() + " " + c.Use
1086 } else {
1087 useline = c.Use
1088 }
1089 if c.DisableFlagsInUseLine {
1090 return useline
1091 }
1092 if c.HasAvailableFlags() && !strings.Contains(useline, "[flags]") {
1093 useline += " [flags]"
1094 }
1095 return useline
1096}
1097
1098// DebugFlags used to determine which flags have been assigned to which commands
1099// and which persist.
1100func (c *Command) DebugFlags() {
1101 c.Println("DebugFlags called on", c.Name())
1102 var debugflags func(*Command)
1103
1104 debugflags = func(x *Command) {
1105 if x.HasFlags() || x.HasPersistentFlags() {
1106 c.Println(x.Name())
1107 }
1108 if x.HasFlags() {
1109 x.flags.VisitAll(func(f *flag.Flag) {
1110 if x.HasPersistentFlags() && x.persistentFlag(f.Name) != nil {
1111 c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [LP]")
1112 } else {
1113 c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]")
1114 }
1115 })
1116 }
1117 if x.HasPersistentFlags() {
1118 x.pflags.VisitAll(func(f *flag.Flag) {
1119 if x.HasFlags() {
1120 if x.flags.Lookup(f.Name) == nil {
1121 c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]")
1122 }
1123 } else {
1124 c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]")
1125 }
1126 })
1127 }
1128 c.Println(x.flagErrorBuf)
1129 if x.HasSubCommands() {
1130 for _, y := range x.commands {
1131 debugflags(y)
1132 }
1133 }
1134 }
1135
1136 debugflags(c)
1137}
1138
1139// Name returns the command's name: the first word in the use line.
1140func (c *Command) Name() string {
1141 name := c.Use
1142 i := strings.Index(name, " ")
1143 if i >= 0 {
1144 name = name[:i]
1145 }
1146 return name
1147}
1148
1149// HasAlias determines if a given string is an alias of the command.
1150func (c *Command) HasAlias(s string) bool {
1151 for _, a := range c.Aliases {
1152 if a == s {
1153 return true
1154 }
1155 }
1156 return false
1157}
1158
1159// CalledAs returns the command name or alias that was used to invoke
1160// this command or an empty string if the command has not been called.
1161func (c *Command) CalledAs() string {
1162 if c.commandCalledAs.called {
1163 return c.commandCalledAs.name
1164 }
1165 return ""
1166}
1167
1168// hasNameOrAliasPrefix returns true if the Name or any of aliases start
1169// with prefix
1170func (c *Command) hasNameOrAliasPrefix(prefix string) bool {
1171 if strings.HasPrefix(c.Name(), prefix) {
1172 c.commandCalledAs.name = c.Name()
1173 return true
1174 }
1175 for _, alias := range c.Aliases {
1176 if strings.HasPrefix(alias, prefix) {
1177 c.commandCalledAs.name = alias
1178 return true
1179 }
1180 }
1181 return false
1182}
1183
1184// NameAndAliases returns a list of the command name and all aliases
1185func (c *Command) NameAndAliases() string {
1186 return strings.Join(append([]string{c.Name()}, c.Aliases...), ", ")
1187}
1188
1189// HasExample determines if the command has example.
1190func (c *Command) HasExample() bool {
1191 return len(c.Example) > 0
1192}
1193
1194// Runnable determines if the command is itself runnable.
1195func (c *Command) Runnable() bool {
1196 return c.Run != nil || c.RunE != nil
1197}
1198
1199// HasSubCommands determines if the command has children commands.
1200func (c *Command) HasSubCommands() bool {
1201 return len(c.commands) > 0
1202}
1203
1204// IsAvailableCommand determines if a command is available as a non-help command
1205// (this includes all non deprecated/hidden commands).
1206func (c *Command) IsAvailableCommand() bool {
1207 if len(c.Deprecated) != 0 || c.Hidden {
1208 return false
1209 }
1210
1211 if c.HasParent() && c.Parent().helpCommand == c {
1212 return false
1213 }
1214
1215 if c.Runnable() || c.HasAvailableSubCommands() {
1216 return true
1217 }
1218
1219 return false
1220}
1221
1222// IsAdditionalHelpTopicCommand determines if a command is an additional
1223// help topic command; additional help topic command is determined by the
1224// fact that it is NOT runnable/hidden/deprecated, and has no sub commands that
1225// are runnable/hidden/deprecated.
1226// Concrete example: https://github.com/spf13/cobra/issues/393#issuecomment-282741924.
1227func (c *Command) IsAdditionalHelpTopicCommand() bool {
1228 // if a command is runnable, deprecated, or hidden it is not a 'help' command
1229 if c.Runnable() || len(c.Deprecated) != 0 || c.Hidden {
1230 return false
1231 }
1232
1233 // if any non-help sub commands are found, the command is not a 'help' command
1234 for _, sub := range c.commands {
1235 if !sub.IsAdditionalHelpTopicCommand() {
1236 return false
1237 }
1238 }
1239
1240 // the command either has no sub commands, or no non-help sub commands
1241 return true
1242}
1243
1244// HasHelpSubCommands determines if a command has any available 'help' sub commands
1245// that need to be shown in the usage/help default template under 'additional help
1246// topics'.
1247func (c *Command) HasHelpSubCommands() bool {
1248 // return true on the first found available 'help' sub command
1249 for _, sub := range c.commands {
1250 if sub.IsAdditionalHelpTopicCommand() {
1251 return true
1252 }
1253 }
1254
1255 // the command either has no sub commands, or no available 'help' sub commands
1256 return false
1257}
1258
1259// HasAvailableSubCommands determines if a command has available sub commands that
1260// need to be shown in the usage/help default template under 'available commands'.
1261func (c *Command) HasAvailableSubCommands() bool {
1262 // return true on the first found available (non deprecated/help/hidden)
1263 // sub command
1264 for _, sub := range c.commands {
1265 if sub.IsAvailableCommand() {
1266 return true
1267 }
1268 }
1269
1270 // the command either has no sub commands, or no available (non deprecated/help/hidden)
1271 // sub commands
1272 return false
1273}
1274
1275// HasParent determines if the command is a child command.
1276func (c *Command) HasParent() bool {
1277 return c.parent != nil
1278}
1279
1280// GlobalNormalizationFunc returns the global normalization function or nil if it doesn't exist.
1281func (c *Command) GlobalNormalizationFunc() func(f *flag.FlagSet, name string) flag.NormalizedName {
1282 return c.globNormFunc
1283}
1284
1285// Flags returns the complete FlagSet that applies
1286// to this command (local and persistent declared here and by all parents).
1287func (c *Command) Flags() *flag.FlagSet {
1288 if c.flags == nil {
1289 c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1290 if c.flagErrorBuf == nil {
1291 c.flagErrorBuf = new(bytes.Buffer)
1292 }
1293 c.flags.SetOutput(c.flagErrorBuf)
1294 }
1295
1296 return c.flags
1297}
1298
1299// LocalNonPersistentFlags are flags specific to this command which will NOT persist to subcommands.
1300func (c *Command) LocalNonPersistentFlags() *flag.FlagSet {
1301 persistentFlags := c.PersistentFlags()
1302
1303 out := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1304 c.LocalFlags().VisitAll(func(f *flag.Flag) {
1305 if persistentFlags.Lookup(f.Name) == nil {
1306 out.AddFlag(f)
1307 }
1308 })
1309 return out
1310}
1311
1312// LocalFlags returns the local FlagSet specifically set in the current command.
1313func (c *Command) LocalFlags() *flag.FlagSet {
1314 c.mergePersistentFlags()
1315
1316 if c.lflags == nil {
1317 c.lflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1318 if c.flagErrorBuf == nil {
1319 c.flagErrorBuf = new(bytes.Buffer)
1320 }
1321 c.lflags.SetOutput(c.flagErrorBuf)
1322 }
1323 c.lflags.SortFlags = c.Flags().SortFlags
1324 if c.globNormFunc != nil {
1325 c.lflags.SetNormalizeFunc(c.globNormFunc)
1326 }
1327
1328 addToLocal := func(f *flag.Flag) {
1329 if c.lflags.Lookup(f.Name) == nil && c.parentsPflags.Lookup(f.Name) == nil {
1330 c.lflags.AddFlag(f)
1331 }
1332 }
1333 c.Flags().VisitAll(addToLocal)
1334 c.PersistentFlags().VisitAll(addToLocal)
1335 return c.lflags
1336}
1337
1338// InheritedFlags returns all flags which were inherited from parents commands.
1339func (c *Command) InheritedFlags() *flag.FlagSet {
1340 c.mergePersistentFlags()
1341
1342 if c.iflags == nil {
1343 c.iflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1344 if c.flagErrorBuf == nil {
1345 c.flagErrorBuf = new(bytes.Buffer)
1346 }
1347 c.iflags.SetOutput(c.flagErrorBuf)
1348 }
1349
1350 local := c.LocalFlags()
1351 if c.globNormFunc != nil {
1352 c.iflags.SetNormalizeFunc(c.globNormFunc)
1353 }
1354
1355 c.parentsPflags.VisitAll(func(f *flag.Flag) {
1356 if c.iflags.Lookup(f.Name) == nil && local.Lookup(f.Name) == nil {
1357 c.iflags.AddFlag(f)
1358 }
1359 })
1360 return c.iflags
1361}
1362
1363// NonInheritedFlags returns all flags which were not inherited from parent commands.
1364func (c *Command) NonInheritedFlags() *flag.FlagSet {
1365 return c.LocalFlags()
1366}
1367
1368// PersistentFlags returns the persistent FlagSet specifically set in the current command.
1369func (c *Command) PersistentFlags() *flag.FlagSet {
1370 if c.pflags == nil {
1371 c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1372 if c.flagErrorBuf == nil {
1373 c.flagErrorBuf = new(bytes.Buffer)
1374 }
1375 c.pflags.SetOutput(c.flagErrorBuf)
1376 }
1377 return c.pflags
1378}
1379
1380// ResetFlags deletes all flags from command.
1381func (c *Command) ResetFlags() {
1382 c.flagErrorBuf = new(bytes.Buffer)
1383 c.flagErrorBuf.Reset()
1384 c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1385 c.flags.SetOutput(c.flagErrorBuf)
1386 c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1387 c.pflags.SetOutput(c.flagErrorBuf)
1388
1389 c.lflags = nil
1390 c.iflags = nil
1391 c.parentsPflags = nil
1392}
1393
1394// HasFlags checks if the command contains any flags (local plus persistent from the entire structure).
1395func (c *Command) HasFlags() bool {
1396 return c.Flags().HasFlags()
1397}
1398
1399// HasPersistentFlags checks if the command contains persistent flags.
1400func (c *Command) HasPersistentFlags() bool {
1401 return c.PersistentFlags().HasFlags()
1402}
1403
1404// HasLocalFlags checks if the command has flags specifically declared locally.
1405func (c *Command) HasLocalFlags() bool {
1406 return c.LocalFlags().HasFlags()
1407}
1408
1409// HasInheritedFlags checks if the command has flags inherited from its parent command.
1410func (c *Command) HasInheritedFlags() bool {
1411 return c.InheritedFlags().HasFlags()
1412}
1413
1414// HasAvailableFlags checks if the command contains any flags (local plus persistent from the entire
1415// structure) which are not hidden or deprecated.
1416func (c *Command) HasAvailableFlags() bool {
1417 return c.Flags().HasAvailableFlags()
1418}
1419
1420// HasAvailablePersistentFlags checks if the command contains persistent flags which are not hidden or deprecated.
1421func (c *Command) HasAvailablePersistentFlags() bool {
1422 return c.PersistentFlags().HasAvailableFlags()
1423}
1424
1425// HasAvailableLocalFlags checks if the command has flags specifically declared locally which are not hidden
1426// or deprecated.
1427func (c *Command) HasAvailableLocalFlags() bool {
1428 return c.LocalFlags().HasAvailableFlags()
1429}
1430
1431// HasAvailableInheritedFlags checks if the command has flags inherited from its parent command which are
1432// not hidden or deprecated.
1433func (c *Command) HasAvailableInheritedFlags() bool {
1434 return c.InheritedFlags().HasAvailableFlags()
1435}
1436
1437// Flag climbs up the command tree looking for matching flag.
1438func (c *Command) Flag(name string) (flag *flag.Flag) {
1439 flag = c.Flags().Lookup(name)
1440
1441 if flag == nil {
1442 flag = c.persistentFlag(name)
1443 }
1444
1445 return
1446}
1447
1448// Recursively find matching persistent flag.
1449func (c *Command) persistentFlag(name string) (flag *flag.Flag) {
1450 if c.HasPersistentFlags() {
1451 flag = c.PersistentFlags().Lookup(name)
1452 }
1453
1454 if flag == nil {
1455 c.updateParentsPflags()
1456 flag = c.parentsPflags.Lookup(name)
1457 }
1458 return
1459}
1460
1461// ParseFlags parses persistent flag tree and local flags.
1462func (c *Command) ParseFlags(args []string) error {
1463 if c.DisableFlagParsing {
1464 return nil
1465 }
1466
1467 if c.flagErrorBuf == nil {
1468 c.flagErrorBuf = new(bytes.Buffer)
1469 }
1470 beforeErrorBufLen := c.flagErrorBuf.Len()
1471 c.mergePersistentFlags()
1472
1473 //do it here after merging all flags and just before parse
1474 c.Flags().ParseErrorsWhitelist = flag.ParseErrorsWhitelist(c.FParseErrWhitelist)
1475
1476 err := c.Flags().Parse(args)
1477 // Print warnings if they occurred (e.g. deprecated flag messages).
1478 if c.flagErrorBuf.Len()-beforeErrorBufLen > 0 && err == nil {
1479 c.Print(c.flagErrorBuf.String())
1480 }
1481
1482 return err
1483}
1484
1485// Parent returns a commands parent command.
1486func (c *Command) Parent() *Command {
1487 return c.parent
1488}
1489
1490// mergePersistentFlags merges c.PersistentFlags() to c.Flags()
1491// and adds missing persistent flags of all parents.
1492func (c *Command) mergePersistentFlags() {
1493 c.updateParentsPflags()
1494 c.Flags().AddFlagSet(c.PersistentFlags())
1495 c.Flags().AddFlagSet(c.parentsPflags)
1496}
1497
1498// updateParentsPflags updates c.parentsPflags by adding
1499// new persistent flags of all parents.
1500// If c.parentsPflags == nil, it makes new.
1501func (c *Command) updateParentsPflags() {
1502 if c.parentsPflags == nil {
1503 c.parentsPflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
1504 c.parentsPflags.SetOutput(c.flagErrorBuf)
1505 c.parentsPflags.SortFlags = false
1506 }
1507
1508 if c.globNormFunc != nil {
1509 c.parentsPflags.SetNormalizeFunc(c.globNormFunc)
1510 }
1511
1512 c.Root().PersistentFlags().AddFlagSet(flag.CommandLine)
1513
1514 c.VisitParents(func(parent *Command) {
1515 c.parentsPflags.AddFlagSet(parent.PersistentFlags())
1516 })
1517}