You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by cc...@apache.org on 2016/03/15 01:27:06 UTC
[30/50] [abbrv] incubator-mynewt-newt git commit: Add static Godeps
for newt repo.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
new file mode 100644
index 0000000..e8c770f
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
@@ -0,0 +1,1169 @@
+package cobra
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "reflect"
+ "runtime"
+ "strings"
+ "testing"
+ "text/template"
+
+ "github.com/spf13/pflag"
+)
+
+var _ = fmt.Println
+var _ = os.Stderr
+
+var tp, te, tt, t1, tr []string
+var rootPersPre, echoPre, echoPersPre, timesPersPre []string
+var flagb1, flagb2, flagb3, flagbr, flagbp bool
+var flags1, flags2a, flags2b, flags3, outs string
+var flagi1, flagi2, flagi3, flagir int
+var globalFlag1 bool
+var flagEcho, rootcalled bool
+var versionUsed int
+
+const strtwoParentHelp = "help message for parent flag strtwo"
+const strtwoChildHelp = "help message for child flag strtwo"
+
+var cmdHidden = &Command{
+ Use: "hide [secret string to print]",
+ Short: "Print anything to screen (if command is known)",
+ Long: `an absolutely utterly useless command for testing.`,
+ Run: func(cmd *Command, args []string) {
+ outs = "hidden"
+ },
+ Hidden: true,
+}
+
+var cmdPrint = &Command{
+ Use: "print [string to print]",
+ Short: "Print anything to the screen",
+ Long: `an absolutely utterly useless command for testing.`,
+ Run: func(cmd *Command, args []string) {
+ tp = args
+ },
+}
+
+var cmdEcho = &Command{
+ Use: "echo [string to echo]",
+ Aliases: []string{"say"},
+ Short: "Echo anything to the screen",
+ Long: `an utterly useless command for testing.`,
+ Example: "Just run cobra-test echo",
+ PersistentPreRun: func(cmd *Command, args []string) {
+ echoPersPre = args
+ },
+ PreRun: func(cmd *Command, args []string) {
+ echoPre = args
+ },
+ Run: func(cmd *Command, args []string) {
+ te = args
+ },
+}
+
+var cmdEchoSub = &Command{
+ Use: "echosub [string to print]",
+ Short: "second sub command for echo",
+ Long: `an absolutely utterly useless command for testing gendocs!.`,
+ Run: func(cmd *Command, args []string) {
+ },
+}
+
+var cmdDeprecated = &Command{
+ Use: "deprecated [can't do anything here]",
+ Short: "A command which is deprecated",
+ Long: `an absolutely utterly useless command for testing deprecation!.`,
+ Deprecated: "Please use echo instead",
+ Run: func(cmd *Command, args []string) {
+ },
+}
+
+var cmdTimes = &Command{
+ Use: "times [# times] [string to echo]",
+ SuggestFor: []string{"counts"},
+ Short: "Echo anything to the screen more times",
+ Long: `a slightly useless command for testing.`,
+ PersistentPreRun: func(cmd *Command, args []string) {
+ timesPersPre = args
+ },
+ Run: func(cmd *Command, args []string) {
+ tt = args
+ },
+}
+
+var cmdRootNoRun = &Command{
+ Use: "cobra-test",
+ Short: "The root can run its own function",
+ Long: "The root description for help",
+ PersistentPreRun: func(cmd *Command, args []string) {
+ rootPersPre = args
+ },
+}
+
+var cmdRootSameName = &Command{
+ Use: "print",
+ Short: "Root with the same name as a subcommand",
+ Long: "The root description for help",
+}
+
+var cmdRootWithRun = &Command{
+ Use: "cobra-test",
+ Short: "The root can run its own function",
+ Long: "The root description for help",
+ Run: func(cmd *Command, args []string) {
+ tr = args
+ rootcalled = true
+ },
+}
+
+var cmdSubNoRun = &Command{
+ Use: "subnorun",
+ Short: "A subcommand without a Run function",
+ Long: "A long output about a subcommand without a Run function",
+}
+
+var cmdVersion1 = &Command{
+ Use: "version",
+ Short: "Print the version number",
+ Long: `First version of the version command`,
+ Run: func(cmd *Command, args []string) {
+ versionUsed = 1
+ },
+}
+
+var cmdVersion2 = &Command{
+ Use: "version",
+ Short: "Print the version number",
+ Long: `Second version of the version command`,
+ Run: func(cmd *Command, args []string) {
+ versionUsed = 2
+ },
+}
+
+var cmdColon = &Command{
+ Use: "cmd:colon",
+ Run: func(cmd *Command, args []string) {
+ },
+}
+
+func flagInit() {
+ cmdEcho.ResetFlags()
+ cmdPrint.ResetFlags()
+ cmdTimes.ResetFlags()
+ cmdRootNoRun.ResetFlags()
+ cmdRootSameName.ResetFlags()
+ cmdRootWithRun.ResetFlags()
+ cmdSubNoRun.ResetFlags()
+ cmdRootNoRun.PersistentFlags().StringVarP(&flags2a, "strtwo", "t", "two", strtwoParentHelp)
+ cmdEcho.Flags().IntVarP(&flagi1, "intone", "i", 123, "help message for flag intone")
+ cmdTimes.Flags().IntVarP(&flagi2, "inttwo", "j", 234, "help message for flag inttwo")
+ cmdPrint.Flags().IntVarP(&flagi3, "intthree", "i", 345, "help message for flag intthree")
+ cmdEcho.PersistentFlags().StringVarP(&flags1, "strone", "s", "one", "help message for flag strone")
+ cmdEcho.PersistentFlags().BoolVarP(&flagbp, "persistentbool", "p", false, "help message for flag persistentbool")
+ cmdTimes.PersistentFlags().StringVarP(&flags2b, "strtwo", "t", "2", strtwoChildHelp)
+ cmdPrint.PersistentFlags().StringVarP(&flags3, "strthree", "s", "three", "help message for flag strthree")
+ cmdEcho.Flags().BoolVarP(&flagb1, "boolone", "b", true, "help message for flag boolone")
+ cmdTimes.Flags().BoolVarP(&flagb2, "booltwo", "c", false, "help message for flag booltwo")
+ cmdPrint.Flags().BoolVarP(&flagb3, "boolthree", "b", true, "help message for flag boolthree")
+ cmdVersion1.ResetFlags()
+ cmdVersion2.ResetFlags()
+}
+
+func commandInit() {
+ cmdEcho.ResetCommands()
+ cmdPrint.ResetCommands()
+ cmdTimes.ResetCommands()
+ cmdRootNoRun.ResetCommands()
+ cmdRootSameName.ResetCommands()
+ cmdRootWithRun.ResetCommands()
+ cmdSubNoRun.ResetCommands()
+}
+
+func initialize() *Command {
+ tt, tp, te = nil, nil, nil
+ rootPersPre, echoPre, echoPersPre, timesPersPre = nil, nil, nil, nil
+
+ var c = cmdRootNoRun
+ flagInit()
+ commandInit()
+ return c
+}
+
+func initializeWithSameName() *Command {
+ tt, tp, te = nil, nil, nil
+ rootPersPre, echoPre, echoPersPre, timesPersPre = nil, nil, nil, nil
+ var c = cmdRootSameName
+ flagInit()
+ commandInit()
+ return c
+}
+
+func initializeWithRootCmd() *Command {
+ cmdRootWithRun.ResetCommands()
+ tt, tp, te, tr, rootcalled = nil, nil, nil, nil, false
+ flagInit()
+ cmdRootWithRun.Flags().BoolVarP(&flagbr, "boolroot", "b", false, "help message for flag boolroot")
+ cmdRootWithRun.Flags().IntVarP(&flagir, "introot", "i", 321, "help message for flag introot")
+ commandInit()
+ return cmdRootWithRun
+}
+
+type resulter struct {
+ Error error
+ Output string
+ Command *Command
+}
+
+func fullSetupTest(input string) resulter {
+ c := initializeWithRootCmd()
+
+ return fullTester(c, input)
+}
+
+func noRRSetupTestSilenced(input string) resulter {
+ c := initialize()
+ c.SilenceErrors = true
+ c.SilenceUsage = true
+ return fullTester(c, input)
+}
+
+func noRRSetupTest(input string) resulter {
+ c := initialize()
+
+ return fullTester(c, input)
+}
+
+func rootOnlySetupTest(input string) resulter {
+ c := initializeWithRootCmd()
+
+ return simpleTester(c, input)
+}
+
+func simpleTester(c *Command, input string) resulter {
+ buf := new(bytes.Buffer)
+ // Testing flag with invalid input
+ c.SetOutput(buf)
+ c.SetArgs(strings.Split(input, " "))
+
+ err := c.Execute()
+ output := buf.String()
+
+ return resulter{err, output, c}
+}
+
+func simpleTesterC(c *Command, input string) resulter {
+ buf := new(bytes.Buffer)
+ // Testing flag with invalid input
+ c.SetOutput(buf)
+ c.SetArgs(strings.Split(input, " "))
+
+ cmd, err := c.ExecuteC()
+ output := buf.String()
+
+ return resulter{err, output, cmd}
+}
+
+func fullTester(c *Command, input string) resulter {
+ buf := new(bytes.Buffer)
+ // Testing flag with invalid input
+ c.SetOutput(buf)
+ cmdEcho.AddCommand(cmdTimes)
+ c.AddCommand(cmdPrint, cmdEcho, cmdSubNoRun, cmdDeprecated)
+ c.SetArgs(strings.Split(input, " "))
+
+ err := c.Execute()
+ output := buf.String()
+
+ return resulter{err, output, c}
+}
+
+func logErr(t *testing.T, found, expected string) {
+ out := new(bytes.Buffer)
+
+ _, _, line, ok := runtime.Caller(2)
+ if ok {
+ fmt.Fprintf(out, "Line: %d ", line)
+ }
+ fmt.Fprintf(out, "Unexpected response.\nExpecting to contain: \n %q\nGot:\n %q\n", expected, found)
+ t.Errorf(out.String())
+}
+
+func checkStringContains(t *testing.T, found, expected string) {
+ if !strings.Contains(found, expected) {
+ logErr(t, found, expected)
+ }
+}
+
+func checkResultContains(t *testing.T, x resulter, check string) {
+ checkStringContains(t, x.Output, check)
+}
+
+func checkStringOmits(t *testing.T, found, expected string) {
+ if strings.Contains(found, expected) {
+ logErr(t, found, expected)
+ }
+}
+
+func checkResultOmits(t *testing.T, x resulter, check string) {
+ checkStringOmits(t, x.Output, check)
+}
+
+func checkOutputContains(t *testing.T, c *Command, check string) {
+ buf := new(bytes.Buffer)
+ c.SetOutput(buf)
+ c.Execute()
+
+ if !strings.Contains(buf.String(), check) {
+ logErr(t, buf.String(), check)
+ }
+}
+
+func TestSingleCommand(t *testing.T) {
+ noRRSetupTest("print one two")
+
+ if te != nil || tt != nil {
+ t.Error("Wrong command called")
+ }
+ if tp == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tp, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+}
+
+func TestChildCommand(t *testing.T) {
+ noRRSetupTest("echo times one two")
+
+ if te != nil || tp != nil {
+ t.Error("Wrong command called")
+ }
+ if tt == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tt, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+}
+
+func TestCommandAlias(t *testing.T) {
+ noRRSetupTest("say times one two")
+
+ if te != nil || tp != nil {
+ t.Error("Wrong command called")
+ }
+ if tt == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tt, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+}
+
+func TestPrefixMatching(t *testing.T) {
+ EnablePrefixMatching = true
+ noRRSetupTest("ech times one two")
+
+ if te != nil || tp != nil {
+ t.Error("Wrong command called")
+ }
+ if tt == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tt, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+
+ EnablePrefixMatching = false
+}
+
+func TestNoPrefixMatching(t *testing.T) {
+ EnablePrefixMatching = false
+
+ noRRSetupTest("ech times one two")
+
+ if !(tt == nil && te == nil && tp == nil) {
+ t.Error("Wrong command called")
+ }
+}
+
+func TestAliasPrefixMatching(t *testing.T) {
+ EnablePrefixMatching = true
+ noRRSetupTest("sa times one two")
+
+ if te != nil || tp != nil {
+ t.Error("Wrong command called")
+ }
+ if tt == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tt, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+ EnablePrefixMatching = false
+}
+
+func TestChildSameName(t *testing.T) {
+ c := initializeWithSameName()
+ c.AddCommand(cmdPrint, cmdEcho)
+ c.SetArgs(strings.Split("print one two", " "))
+ c.Execute()
+
+ if te != nil || tt != nil {
+ t.Error("Wrong command called")
+ }
+ if tp == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tp, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+}
+
+func TestGrandChildSameName(t *testing.T) {
+ c := initializeWithSameName()
+ cmdTimes.AddCommand(cmdPrint)
+ c.AddCommand(cmdTimes)
+ c.SetArgs(strings.Split("times print one two", " "))
+ c.Execute()
+
+ if te != nil || tt != nil {
+ t.Error("Wrong command called")
+ }
+ if tp == nil {
+ t.Error("Wrong command called")
+ }
+ if strings.Join(tp, " ") != "one two" {
+ t.Error("Command didn't parse correctly")
+ }
+}
+
+func TestFlagLong(t *testing.T) {
+ noRRSetupTest("echo --intone=13 something -- here")
+
+ if cmdEcho.ArgsLenAtDash() != 1 {
+ t.Errorf("expected argsLenAtDash: %d but got %d", 1, cmdRootNoRun.ArgsLenAtDash())
+ }
+ if strings.Join(te, " ") != "something here" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", te)
+ }
+ if flagi1 != 13 {
+ t.Errorf("int flag didn't get correct value, had %d", flagi1)
+ }
+ if flagi2 != 234 {
+ t.Errorf("default flag value changed, 234 expected, %d given", flagi2)
+ }
+}
+
+func TestFlagShort(t *testing.T) {
+ noRRSetupTest("echo -i13 -- something here")
+
+ if cmdEcho.ArgsLenAtDash() != 0 {
+ t.Errorf("expected argsLenAtDash: %d but got %d", 0, cmdRootNoRun.ArgsLenAtDash())
+ }
+ if strings.Join(te, " ") != "something here" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", te)
+ }
+ if flagi1 != 13 {
+ t.Errorf("int flag didn't get correct value, had %d", flagi1)
+ }
+ if flagi2 != 234 {
+ t.Errorf("default flag value changed, 234 expected, %d given", flagi2)
+ }
+
+ noRRSetupTest("echo -i 13 something here")
+
+ if strings.Join(te, " ") != "something here" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", te)
+ }
+ if flagi1 != 13 {
+ t.Errorf("int flag didn't get correct value, had %d", flagi1)
+ }
+ if flagi2 != 234 {
+ t.Errorf("default flag value changed, 234 expected, %d given", flagi2)
+ }
+
+ noRRSetupTest("print -i99 one two")
+
+ if strings.Join(tp, " ") != "one two" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", tp)
+ }
+ if flagi3 != 99 {
+ t.Errorf("int flag didn't get correct value, had %d", flagi3)
+ }
+ if flagi1 != 123 {
+ t.Errorf("default flag value changed on different command with same shortname, 234 expected, %d given", flagi2)
+ }
+}
+
+func TestChildCommandFlags(t *testing.T) {
+ noRRSetupTest("echo times -j 99 one two")
+
+ if strings.Join(tt, " ") != "one two" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", tt)
+ }
+
+ // Testing with flag that shouldn't be persistent
+ r := noRRSetupTest("echo times -j 99 -i77 one two")
+
+ if r.Error == nil {
+ t.Errorf("invalid flag should generate error")
+ }
+
+ if !strings.Contains(r.Error.Error(), "unknown shorthand") {
+ t.Errorf("Wrong error message displayed, \n %s", r.Error)
+ }
+
+ if flagi2 != 99 {
+ t.Errorf("flag value should be 99, %d given", flagi2)
+ }
+
+ if flagi1 != 123 {
+ t.Errorf("unset flag should have default value, expecting 123, given %d", flagi1)
+ }
+
+ // Testing with flag only existing on child
+ r = noRRSetupTest("echo -j 99 -i77 one two")
+
+ if r.Error == nil {
+ t.Errorf("invalid flag should generate error")
+ }
+ if !strings.Contains(r.Error.Error(), "unknown shorthand flag") {
+ t.Errorf("Wrong error message displayed, \n %s", r.Error)
+ }
+
+ // Testing with persistent flag overwritten by child
+ noRRSetupTest("echo times --strtwo=child one two")
+
+ if flags2b != "child" {
+ t.Errorf("flag value should be child, %s given", flags2b)
+ }
+
+ if flags2a != "two" {
+ t.Errorf("unset flag should have default value, expecting two, given %s", flags2a)
+ }
+
+ // Testing flag with invalid input
+ r = noRRSetupTest("echo -i10E")
+
+ if r.Error == nil {
+ t.Errorf("invalid input should generate error")
+ }
+ if !strings.Contains(r.Error.Error(), "invalid argument \"10E\" for i10E") {
+ t.Errorf("Wrong error message displayed, \n %s", r.Error)
+ }
+}
+
+func TestTrailingCommandFlags(t *testing.T) {
+ x := fullSetupTest("echo two -x")
+
+ if x.Error == nil {
+ t.Errorf("invalid flag should generate error")
+ }
+}
+
+func TestInvalidSubcommandFlags(t *testing.T) {
+ cmd := initializeWithRootCmd()
+ cmd.AddCommand(cmdTimes)
+
+ result := simpleTester(cmd, "times --inttwo=2 --badflag=bar")
+ // given that we are not checking here result.Error we check for
+ // stock usage message
+ checkResultContains(t, result, "cobra-test times [# times]")
+ if strings.Contains(result.Error.Error(), "unknown flag: --inttwo") {
+ t.Errorf("invalid --badflag flag shouldn't fail on 'unknown' --inttwo flag")
+ }
+
+}
+
+func TestSubcommandExecuteC(t *testing.T) {
+ cmd := initializeWithRootCmd()
+ double := &Command{
+ Use: "double message",
+ Run: func(c *Command, args []string) {
+ msg := strings.Join(args, " ")
+ c.Println(msg, msg)
+ },
+ }
+
+ echo := &Command{
+ Use: "echo message",
+ Run: func(c *Command, args []string) {
+ msg := strings.Join(args, " ")
+ c.Println(msg, msg)
+ },
+ }
+
+ cmd.AddCommand(double, echo)
+
+ result := simpleTesterC(cmd, "double hello world")
+ checkResultContains(t, result, "hello world hello world")
+
+ if result.Command.Name() != "double" {
+ t.Errorf("invalid cmd returned from ExecuteC: should be 'double' but got %s", result.Command.Name())
+ }
+
+ result = simpleTesterC(cmd, "echo msg to be echoed")
+ checkResultContains(t, result, "msg to be echoed")
+
+ if result.Command.Name() != "echo" {
+ t.Errorf("invalid cmd returned from ExecuteC: should be 'echo' but got %s", result.Command.Name())
+ }
+}
+
+func TestSubcommandArgEvaluation(t *testing.T) {
+ cmd := initializeWithRootCmd()
+
+ first := &Command{
+ Use: "first",
+ Run: func(cmd *Command, args []string) {
+ },
+ }
+ cmd.AddCommand(first)
+
+ second := &Command{
+ Use: "second",
+ Run: func(cmd *Command, args []string) {
+ fmt.Fprintf(cmd.Out(), "%v", args)
+ },
+ }
+ first.AddCommand(second)
+
+ result := simpleTester(cmd, "first second first third")
+
+ expectedOutput := fmt.Sprintf("%v", []string{"first third"})
+ if result.Output != expectedOutput {
+ t.Errorf("exptected %v, got %v", expectedOutput, result.Output)
+ }
+}
+
+func TestPersistentFlags(t *testing.T) {
+ fullSetupTest("echo -s something -p more here")
+
+ // persistentFlag should act like normal flag on its own command
+ if strings.Join(te, " ") != "more here" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", te)
+ }
+ if flags1 != "something" {
+ t.Errorf("string flag didn't get correct value, had %v", flags1)
+ }
+ if !flagbp {
+ t.Errorf("persistent bool flag not parsed correctly. Expected true, had %v", flagbp)
+ }
+
+ // persistentFlag should act like normal flag on its own command
+ fullSetupTest("echo times -s again -c -p test here")
+
+ if strings.Join(tt, " ") != "test here" {
+ t.Errorf("flags didn't leave proper args remaining..%s given", tt)
+ }
+
+ if flags1 != "again" {
+ t.Errorf("string flag didn't get correct value, had %v", flags1)
+ }
+
+ if !flagb2 {
+ t.Errorf("local flag not parsed correctly. Expected true, had %v", flagb2)
+ }
+ if !flagbp {
+ t.Errorf("persistent bool flag not parsed correctly. Expected true, had %v", flagbp)
+ }
+}
+
+func TestHelpCommand(t *testing.T) {
+ x := fullSetupTest("help")
+ checkResultContains(t, x, cmdRootWithRun.Long)
+
+ x = fullSetupTest("help echo")
+ checkResultContains(t, x, cmdEcho.Long)
+
+ x = fullSetupTest("help echo times")
+ checkResultContains(t, x, cmdTimes.Long)
+}
+
+func TestChildCommandHelp(t *testing.T) {
+ c := noRRSetupTest("print --help")
+ checkResultContains(t, c, strtwoParentHelp)
+ r := noRRSetupTest("echo times --help")
+ checkResultContains(t, r, strtwoChildHelp)
+}
+
+func TestNonRunChildHelp(t *testing.T) {
+ x := noRRSetupTest("subnorun")
+ checkResultContains(t, x, cmdSubNoRun.Long)
+}
+
+func TestRunnableRootCommand(t *testing.T) {
+ x := fullSetupTest("")
+
+ if rootcalled != true {
+ t.Errorf("Root Function was not called\n out:%v", x.Error)
+ }
+}
+
+func TestVisitParents(t *testing.T) {
+ c := &Command{Use: "app"}
+ sub := &Command{Use: "sub"}
+ dsub := &Command{Use: "dsub"}
+ sub.AddCommand(dsub)
+ c.AddCommand(sub)
+ total := 0
+ add := func(x *Command) {
+ total++
+ }
+ sub.VisitParents(add)
+ if total != 1 {
+ t.Errorf("Should have visited 1 parent but visited %d", total)
+ }
+
+ total = 0
+ dsub.VisitParents(add)
+ if total != 2 {
+ t.Errorf("Should have visited 2 parent but visited %d", total)
+ }
+
+ total = 0
+ c.VisitParents(add)
+ if total != 0 {
+ t.Errorf("Should have not visited any parent but visited %d", total)
+ }
+}
+
+func TestRunnableRootCommandNilInput(t *testing.T) {
+ empty_arg := make([]string, 0)
+ c := initializeWithRootCmd()
+
+ buf := new(bytes.Buffer)
+ // Testing flag with invalid input
+ c.SetOutput(buf)
+ cmdEcho.AddCommand(cmdTimes)
+ c.AddCommand(cmdPrint, cmdEcho)
+ c.SetArgs(empty_arg)
+
+ err := c.Execute()
+ if err != nil {
+ t.Errorf("Execute() failed with %v", err)
+ }
+
+ if rootcalled != true {
+ t.Errorf("Root Function was not called")
+ }
+}
+
+func TestRunnableRootCommandEmptyInput(t *testing.T) {
+ args := make([]string, 3)
+ args[0] = ""
+ args[1] = "--introot=12"
+ args[2] = ""
+ c := initializeWithRootCmd()
+
+ buf := new(bytes.Buffer)
+ // Testing flag with invalid input
+ c.SetOutput(buf)
+ cmdEcho.AddCommand(cmdTimes)
+ c.AddCommand(cmdPrint, cmdEcho)
+ c.SetArgs(args)
+
+ c.Execute()
+
+ if rootcalled != true {
+ t.Errorf("Root Function was not called.\n\nOutput was:\n\n%s\n", buf)
+ }
+}
+
+func TestInvalidSubcommandWhenArgsAllowed(t *testing.T) {
+ fullSetupTest("echo invalid-sub")
+
+ if te[0] != "invalid-sub" {
+ t.Errorf("Subcommand didn't work...")
+ }
+}
+
+func TestRootFlags(t *testing.T) {
+ fullSetupTest("-i 17 -b")
+
+ if flagbr != true {
+ t.Errorf("flag value should be true, %v given", flagbr)
+ }
+
+ if flagir != 17 {
+ t.Errorf("flag value should be 17, %d given", flagir)
+ }
+}
+
+func TestRootHelp(t *testing.T) {
+ x := fullSetupTest("--help")
+
+ checkResultContains(t, x, "Available Commands:")
+ checkResultContains(t, x, "for more information about a command")
+
+ if strings.Contains(x.Output, "unknown flag: --help") {
+ t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output)
+ }
+
+ if strings.Contains(x.Output, cmdEcho.Use) {
+ t.Errorf("--help shouldn't display subcommand's usage, Got: \n %s", x.Output)
+ }
+
+ x = fullSetupTest("echo --help")
+
+ if strings.Contains(x.Output, cmdTimes.Use) {
+ t.Errorf("--help shouldn't display subsubcommand's usage, Got: \n %s", x.Output)
+ }
+
+ checkResultContains(t, x, "Available Commands:")
+ checkResultContains(t, x, "for more information about a command")
+
+ if strings.Contains(x.Output, "unknown flag: --help") {
+ t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output)
+ }
+
+}
+
+func TestFlagAccess(t *testing.T) {
+ initialize()
+
+ local := cmdTimes.LocalFlags()
+ inherited := cmdTimes.InheritedFlags()
+
+ for _, f := range []string{"inttwo", "strtwo", "booltwo"} {
+ if local.Lookup(f) == nil {
+ t.Errorf("LocalFlags expected to contain %s, Got: nil", f)
+ }
+ }
+ if inherited.Lookup("strone") == nil {
+ t.Errorf("InheritedFlags expected to contain strone, Got: nil")
+ }
+ if inherited.Lookup("strtwo") != nil {
+ t.Errorf("InheritedFlags shouldn not contain overwritten flag strtwo")
+
+ }
+}
+
+func TestNoNRunnableRootCommandNilInput(t *testing.T) {
+ args := make([]string, 0)
+ c := initialize()
+
+ buf := new(bytes.Buffer)
+ // Testing flag with invalid input
+ c.SetOutput(buf)
+ cmdEcho.AddCommand(cmdTimes)
+ c.AddCommand(cmdPrint, cmdEcho)
+ c.SetArgs(args)
+
+ c.Execute()
+
+ if !strings.Contains(buf.String(), cmdRootNoRun.Long) {
+ t.Errorf("Expected to get help output, Got: \n %s", buf)
+ }
+}
+
+func TestRootNoCommandHelp(t *testing.T) {
+ x := rootOnlySetupTest("--help")
+
+ checkResultOmits(t, x, "Available Commands:")
+ checkResultOmits(t, x, "for more information about a command")
+
+ if strings.Contains(x.Output, "unknown flag: --help") {
+ t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output)
+ }
+
+ x = rootOnlySetupTest("echo --help")
+
+ checkResultOmits(t, x, "Available Commands:")
+ checkResultOmits(t, x, "for more information about a command")
+
+ if strings.Contains(x.Output, "unknown flag: --help") {
+ t.Errorf("--help shouldn't trigger an error, Got: \n %s", x.Output)
+ }
+}
+
+func TestRootUnknownCommand(t *testing.T) {
+ r := noRRSetupTest("bogus")
+ s := "Error: unknown command \"bogus\" for \"cobra-test\"\nRun 'cobra-test --help' for usage.\n"
+
+ if r.Output != s {
+ t.Errorf("Unexpected response.\nExpecting to be:\n %q\nGot:\n %q\n", s, r.Output)
+ }
+
+ r = noRRSetupTest("--strtwo=a bogus")
+ if r.Output != s {
+ t.Errorf("Unexpected response.\nExpecting to be:\n %q\nGot:\n %q\n", s, r.Output)
+ }
+}
+
+func TestRootUnknownCommandSilenced(t *testing.T) {
+ r := noRRSetupTestSilenced("bogus")
+ s := "Run 'cobra-test --help' for usage.\n"
+
+ if r.Output != "" {
+ t.Errorf("Unexpected response.\nExpecting to be: \n\"\"\n Got:\n %q\n", s, r.Output)
+ }
+
+ r = noRRSetupTestSilenced("--strtwo=a bogus")
+ if r.Output != "" {
+ t.Errorf("Unexpected response.\nExpecting to be:\n\"\"\nGot:\n %q\n", s, r.Output)
+ }
+}
+
+func TestRootSuggestions(t *testing.T) {
+ outputWithSuggestions := "Error: unknown command \"%s\" for \"cobra-test\"\n\nDid you mean this?\n\t%s\n\nRun 'cobra-test --help' for usage.\n"
+ outputWithoutSuggestions := "Error: unknown command \"%s\" for \"cobra-test\"\nRun 'cobra-test --help' for usage.\n"
+
+ cmd := initializeWithRootCmd()
+ cmd.AddCommand(cmdTimes)
+
+ tests := map[string]string{
+ "time": "times",
+ "tiems": "times",
+ "tims": "times",
+ "timeS": "times",
+ "rimes": "times",
+ "ti": "times",
+ "t": "times",
+ "timely": "times",
+ "ri": "",
+ "timezone": "",
+ "foo": "",
+ "counts": "times",
+ }
+
+ for typo, suggestion := range tests {
+ for _, suggestionsDisabled := range []bool{false, true} {
+ cmd.DisableSuggestions = suggestionsDisabled
+ result := simpleTester(cmd, typo)
+ expected := ""
+ if len(suggestion) == 0 || suggestionsDisabled {
+ expected = fmt.Sprintf(outputWithoutSuggestions, typo)
+ } else {
+ expected = fmt.Sprintf(outputWithSuggestions, typo, suggestion)
+ }
+ if result.Output != expected {
+ t.Errorf("Unexpected response.\nExpecting to be:\n %q\nGot:\n %q\n", expected, result.Output)
+ }
+ }
+ }
+}
+
+func TestFlagsBeforeCommand(t *testing.T) {
+ // short without space
+ x := fullSetupTest("-i10 echo")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error)
+ }
+
+ // short (int) with equals
+ // It appears that pflags doesn't support this...
+ // Commenting out until support can be added
+
+ //x = noRRSetupTest("echo -i=10")
+ //if x.Error != nil {
+ //t.Errorf("Valid Input shouldn't have errors, got:\n %s", x.Error)
+ //}
+
+ // long with equals
+ x = noRRSetupTest("--intone=123 echo one two")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %s", x.Error)
+ }
+
+ // With parsing error properly reported
+ x = fullSetupTest("-i10E echo")
+ if !strings.Contains(x.Error.Error(), "invalid argument \"10E\" for i10E") {
+ t.Errorf("Wrong error message displayed, \n %s", x.Error)
+ }
+
+ //With quotes
+ x = fullSetupTest("-s=\"walking\" echo")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error)
+ }
+
+ //With quotes and space
+ x = fullSetupTest("-s=\"walking fast\" echo")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error)
+ }
+
+ //With inner quote
+ x = fullSetupTest("-s=\"walking \\\"Inner Quote\\\" fast\" echo")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error)
+ }
+
+ //With quotes and space
+ x = fullSetupTest("-s=\"walking \\\"Inner Quote\\\" fast\" echo")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error)
+ }
+
+}
+
+func TestRemoveCommand(t *testing.T) {
+ versionUsed = 0
+ c := initializeWithRootCmd()
+ c.AddCommand(cmdVersion1)
+ c.RemoveCommand(cmdVersion1)
+ x := fullTester(c, "version")
+ if x.Error == nil {
+ t.Errorf("Removed command should not have been called\n")
+ return
+ }
+}
+
+func TestCommandWithoutSubcommands(t *testing.T) {
+ c := initializeWithRootCmd()
+
+ x := simpleTester(c, "")
+ if x.Error != nil {
+ t.Errorf("Calling command without subcommands should not have error: %v", x.Error)
+ return
+ }
+}
+
+func TestCommandWithoutSubcommandsWithArg(t *testing.T) {
+ c := initializeWithRootCmd()
+ expectedArgs := []string{"arg"}
+
+ x := simpleTester(c, "arg")
+ if x.Error != nil {
+ t.Errorf("Calling command without subcommands but with arg should not have error: %v", x.Error)
+ return
+ }
+ if !reflect.DeepEqual(expectedArgs, tr) {
+ t.Errorf("Calling command without subcommands but with arg has wrong args: expected: %v, actual: %v", expectedArgs, tr)
+ return
+ }
+}
+
+func TestReplaceCommandWithRemove(t *testing.T) {
+ versionUsed = 0
+ c := initializeWithRootCmd()
+ c.AddCommand(cmdVersion1)
+ c.RemoveCommand(cmdVersion1)
+ c.AddCommand(cmdVersion2)
+ x := fullTester(c, "version")
+ if x.Error != nil {
+ t.Errorf("Valid Input shouldn't have errors, got:\n %q", x.Error)
+ return
+ }
+ if versionUsed == 1 {
+ t.Errorf("Removed command shouldn't be called\n")
+ }
+ if versionUsed != 2 {
+ t.Errorf("Replacing command should have been called but didn't\n")
+ }
+}
+
+func TestDeprecatedSub(t *testing.T) {
+ c := fullSetupTest("deprecated")
+
+ checkResultContains(t, c, cmdDeprecated.Deprecated)
+}
+
+func TestPreRun(t *testing.T) {
+ noRRSetupTest("echo one two")
+ if echoPre == nil || echoPersPre == nil {
+ t.Error("PreRun or PersistentPreRun not called")
+ }
+ if rootPersPre != nil || timesPersPre != nil {
+ t.Error("Wrong *Pre functions called!")
+ }
+
+ noRRSetupTest("echo times one two")
+ if timesPersPre == nil {
+ t.Error("PreRun or PersistentPreRun not called")
+ }
+ if echoPre != nil || echoPersPre != nil || rootPersPre != nil {
+ t.Error("Wrong *Pre functions called!")
+ }
+
+ noRRSetupTest("print one two")
+ if rootPersPre == nil {
+ t.Error("Parent PersistentPreRun not called but should not have been")
+ }
+ if echoPre != nil || echoPersPre != nil || timesPersPre != nil {
+ t.Error("Wrong *Pre functions called!")
+ }
+}
+
+// Check if cmdEchoSub gets PersistentPreRun from rootCmd even if is added last
+func TestPeristentPreRunPropagation(t *testing.T) {
+ rootCmd := initialize()
+
+ // First add the cmdEchoSub to cmdPrint
+ cmdPrint.AddCommand(cmdEchoSub)
+ // Now add cmdPrint to rootCmd
+ rootCmd.AddCommand(cmdPrint)
+
+ rootCmd.SetArgs(strings.Split("print echosub lala", " "))
+ rootCmd.Execute()
+
+ if rootPersPre == nil || len(rootPersPre) == 0 || rootPersPre[0] != "lala" {
+ t.Error("RootCmd PersistentPreRun not called but should have been")
+ }
+}
+
+func TestGlobalNormFuncPropagation(t *testing.T) {
+ normFunc := func(f *pflag.FlagSet, name string) pflag.NormalizedName {
+ return pflag.NormalizedName(name)
+ }
+
+ rootCmd := initialize()
+ rootCmd.SetGlobalNormalizationFunc(normFunc)
+ if reflect.ValueOf(normFunc) != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()) {
+ t.Error("rootCmd seems to have a wrong normalization function")
+ }
+
+ // First add the cmdEchoSub to cmdPrint
+ cmdPrint.AddCommand(cmdEchoSub)
+ if cmdPrint.GlobalNormalizationFunc() != nil && cmdEchoSub.GlobalNormalizationFunc() != nil {
+ t.Error("cmdPrint and cmdEchoSub should had no normalization functions")
+ }
+
+ // Now add cmdPrint to rootCmd
+ rootCmd.AddCommand(cmdPrint)
+ if reflect.ValueOf(cmdPrint.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() ||
+ reflect.ValueOf(cmdEchoSub.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(rootCmd.GlobalNormalizationFunc()).Pointer() {
+ t.Error("cmdPrint and cmdEchoSub should had the normalization function of rootCmd")
+ }
+}
+
+func TestFlagOnPflagCommandLine(t *testing.T) {
+ flagName := "flagOnCommandLine"
+ pflag.CommandLine.String(flagName, "", "about my flag")
+ r := fullSetupTest("--help")
+
+ checkResultContains(t, r, flagName)
+}
+
+func TestAddTemplateFunctions(t *testing.T) {
+ AddTemplateFunc("t", func() bool { return true })
+ AddTemplateFuncs(template.FuncMap{
+ "f": func() bool { return false },
+ "h": func() string { return "Hello," },
+ "w": func() string { return "world." }})
+
+ const usage = "Hello, world."
+
+ c := &Command{}
+ c.SetUsageTemplate(`{{if t}}{{h}}{{end}}{{if f}}{{h}}{{end}} {{w}}`)
+
+ if us := c.UsageString(); us != usage {
+ t.Errorf("c.UsageString() != \"%s\", is \"%s\"", usage, us)
+ }
+}
+
+func TestUsageIsNotPrintedTwice(t *testing.T) {
+ var cmd = &Command{Use: "root"}
+ var sub = &Command{Use: "sub"}
+ cmd.AddCommand(sub)
+
+ r := simpleTester(cmd, "")
+ if strings.Count(r.Output, "Usage:") != 1 {
+ t.Error("Usage output is not printed exactly once")
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/command.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command.go
new file mode 100644
index 0000000..ccc41c3
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command.go
@@ -0,0 +1,1197 @@
+// Copyright © 2013 Steve Francia <sp...@spf13.com>.
+//
+// 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.
+
+//Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces.
+//In addition to providing an interface, Cobra simultaneously provides a controller to organize your application code.
+package cobra
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+
+ flag "github.com/spf13/pflag"
+)
+
+// Command is just that, a command for your application.
+// eg. 'go run' ... 'run' is the command. Cobra requires
+// you to define the usage and description as part of your command
+// definition to ensure usability.
+type Command struct {
+ // Name is the command name, usually the executable's name.
+ name string
+ // The one-line usage message.
+ Use string
+ // An array of aliases that can be used instead of the first word in Use.
+ Aliases []string
+ // An array of command names for which this command will be suggested - similar to aliases but only suggests.
+ SuggestFor []string
+ // The short description shown in the 'help' output.
+ Short string
+ // The long message shown in the 'help <this-command>' output.
+ Long string
+ // Examples of how to use the command
+ Example string
+ // List of all valid non-flag arguments, used for bash completions *TODO* actually validate these
+ ValidArgs []string
+ // Custom functions used by the bash autocompletion generator
+ BashCompletionFunction string
+ // Is this command deprecated and should print this string when used?
+ Deprecated string
+ // Is this command hidden and should NOT show up in the list of available commands?
+ Hidden bool
+ // Full set of flags
+ flags *flag.FlagSet
+ // Set of flags childrens of this command will inherit
+ pflags *flag.FlagSet
+ // Flags that are declared specifically by this command (not inherited).
+ lflags *flag.FlagSet
+ // SilenceErrors is an option to quiet errors down stream
+ SilenceErrors bool
+ // Silence Usage is an option to silence usage when an error occurs.
+ SilenceUsage bool
+ // The *Run functions are executed in the following order:
+ // * PersistentPreRun()
+ // * PreRun()
+ // * Run()
+ // * PostRun()
+ // * PersistentPostRun()
+ // All functions get the same args, the arguments after the command name
+ // PersistentPreRun: children of this command will inherit and execute
+ PersistentPreRun func(cmd *Command, args []string)
+ // PersistentPreRunE: PersistentPreRun but returns an error
+ PersistentPreRunE func(cmd *Command, args []string) error
+ // PreRun: children of this command will not inherit.
+ PreRun func(cmd *Command, args []string)
+ // PreRunE: PreRun but returns an error
+ PreRunE func(cmd *Command, args []string) error
+ // Run: Typically the actual work function. Most commands will only implement this
+ Run func(cmd *Command, args []string)
+ // RunE: Run but returns an error
+ RunE func(cmd *Command, args []string) error
+ // PostRun: run after the Run command.
+ PostRun func(cmd *Command, args []string)
+ // PostRunE: PostRun but returns an error
+ PostRunE func(cmd *Command, args []string) error
+ // PersistentPostRun: children of this command will inherit and execute after PostRun
+ PersistentPostRun func(cmd *Command, args []string)
+ // PersistentPostRunE: PersistentPostRun but returns an error
+ PersistentPostRunE func(cmd *Command, args []string) error
+ // DisableAutoGenTag remove
+ DisableAutoGenTag bool
+ // Commands is the list of commands supported by this program.
+ commands []*Command
+ // Parent Command for this command
+ parent *Command
+ // max lengths of commands' string lengths for use in padding
+ commandsMaxUseLen int
+ commandsMaxCommandPathLen int
+ commandsMaxNameLen int
+
+ flagErrorBuf *bytes.Buffer
+
+ args []string // actual args parsed from flags
+ output *io.Writer // nil means stderr; use Out() method instead
+ usageFunc func(*Command) error // Usage can be defined by application
+ usageTemplate string // Can be defined by Application
+ helpTemplate string // Can be defined by Application
+ helpFunc func(*Command, []string) // Help can be defined by application
+ helpCommand *Command // The help command
+ // The global normalization function that we can use on every pFlag set and children commands
+ globNormFunc func(f *flag.FlagSet, name string) flag.NormalizedName
+
+ // Disable the suggestions based on Levenshtein distance that go along with 'unknown command' messages
+ DisableSuggestions bool
+ // If displaying suggestions, allows to set the minimum levenshtein distance to display, must be > 0
+ SuggestionsMinimumDistance int
+}
+
+// os.Args[1:] by default, if desired, can be overridden
+// particularly useful when testing.
+func (c *Command) SetArgs(a []string) {
+ c.args = a
+}
+
+func (c *Command) getOut(def io.Writer) io.Writer {
+ if c.output != nil {
+ return *c.output
+ }
+
+ if c.HasParent() {
+ return c.parent.Out()
+ } else {
+ return def
+ }
+}
+
+func (c *Command) Out() io.Writer {
+ return c.getOut(os.Stderr)
+}
+
+func (c *Command) getOutOrStdout() io.Writer {
+ return c.getOut(os.Stdout)
+}
+
+// SetOutput sets the destination for usage and error messages.
+// If output is nil, os.Stderr is used.
+func (c *Command) SetOutput(output io.Writer) {
+ c.output = &output
+}
+
+// Usage can be defined by application
+func (c *Command) SetUsageFunc(f func(*Command) error) {
+ c.usageFunc = f
+}
+
+// Can be defined by Application
+func (c *Command) SetUsageTemplate(s string) {
+ c.usageTemplate = s
+}
+
+// Can be defined by Application
+func (c *Command) SetHelpFunc(f func(*Command, []string)) {
+ c.helpFunc = f
+}
+
+func (c *Command) SetHelpCommand(cmd *Command) {
+ c.helpCommand = cmd
+}
+
+// Can be defined by Application
+func (c *Command) SetHelpTemplate(s string) {
+ c.helpTemplate = s
+}
+
+// SetGlobalNormalizationFunc sets a normalization function to all flag sets and also to child commands.
+// The user should not have a cyclic dependency on commands.
+func (c *Command) SetGlobalNormalizationFunc(n func(f *flag.FlagSet, name string) flag.NormalizedName) {
+ c.Flags().SetNormalizeFunc(n)
+ c.PersistentFlags().SetNormalizeFunc(n)
+ c.globNormFunc = n
+
+ for _, command := range c.commands {
+ command.SetGlobalNormalizationFunc(n)
+ }
+}
+
+func (c *Command) UsageFunc() (f func(*Command) error) {
+ if c.usageFunc != nil {
+ return c.usageFunc
+ }
+
+ if c.HasParent() {
+ return c.parent.UsageFunc()
+ } else {
+ return func(c *Command) error {
+ err := tmpl(c.Out(), c.UsageTemplate(), c)
+ if err != nil {
+ fmt.Print(err)
+ }
+ return err
+ }
+ }
+}
+
+// HelpFunc returns either the function set by SetHelpFunc for this command
+// or a parent, or it returns a function which calls c.Help()
+func (c *Command) HelpFunc() func(*Command, []string) {
+ cmd := c
+ for cmd != nil {
+ if cmd.helpFunc != nil {
+ return cmd.helpFunc
+ }
+ cmd = cmd.parent
+ }
+ return func(*Command, []string) {
+ err := c.Help()
+ if err != nil {
+ c.Println(err)
+ }
+ }
+}
+
+var minUsagePadding int = 25
+
+func (c *Command) UsagePadding() int {
+ if c.parent == nil || minUsagePadding > c.parent.commandsMaxUseLen {
+ return minUsagePadding
+ } else {
+ return c.parent.commandsMaxUseLen
+ }
+}
+
+var minCommandPathPadding int = 11
+
+//
+func (c *Command) CommandPathPadding() int {
+ if c.parent == nil || minCommandPathPadding > c.parent.commandsMaxCommandPathLen {
+ return minCommandPathPadding
+ } else {
+ return c.parent.commandsMaxCommandPathLen
+ }
+}
+
+var minNamePadding int = 11
+
+func (c *Command) NamePadding() int {
+ if c.parent == nil || minNamePadding > c.parent.commandsMaxNameLen {
+ return minNamePadding
+ } else {
+ return c.parent.commandsMaxNameLen
+ }
+}
+
+func (c *Command) UsageTemplate() string {
+ if c.usageTemplate != "" {
+ return c.usageTemplate
+ }
+
+ if c.HasParent() {
+ return c.parent.UsageTemplate()
+ } else {
+ return `Usage:{{if .Runnable}}
+ {{.UseLine}}{{if .HasFlags}} [flags]{{end}}{{end}}{{if .HasSubCommands}}
+ {{ .CommandPath}} [command]{{end}}{{if gt .Aliases 0}}
+
+Aliases:
+ {{.NameAndAliases}}
+{{end}}{{if .HasExample}}
+
+Examples:
+{{ .Example }}{{end}}{{ if .HasAvailableSubCommands}}
+
+Available Commands:{{range .Commands}}{{if .IsAvailableCommand}}
+ {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasLocalFlags}}
+
+Flags:
+{{.LocalFlags.FlagUsages | trimRightSpace}}{{end}}{{ if .HasInheritedFlags}}
+
+Global Flags:
+{{.InheritedFlags.FlagUsages | trimRightSpace}}{{end}}{{if .HasHelpSubCommands}}
+
+Additional help topics:{{range .Commands}}{{if .IsHelpCommand}}
+ {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{ if .HasSubCommands }}
+
+Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
+`
+ }
+}
+
+func (c *Command) HelpTemplate() string {
+ if c.helpTemplate != "" {
+ return c.helpTemplate
+ }
+
+ if c.HasParent() {
+ return c.parent.HelpTemplate()
+ } else {
+ return `{{with or .Long .Short }}{{. | trim}}
+
+{{end}}{{if or .Runnable .HasSubCommands}}{{.UsageString}}{{end}}`
+ }
+}
+
+// Really only used when casting a command to a commander
+func (c *Command) resetChildrensParents() {
+ for _, x := range c.commands {
+ x.parent = c
+ }
+}
+
+// Test if the named flag is a boolean flag.
+func isBooleanFlag(name string, f *flag.FlagSet) bool {
+ flag := f.Lookup(name)
+ if flag == nil {
+ return false
+ }
+ return flag.Value.Type() == "bool"
+}
+
+// Test if the named flag is a boolean flag.
+func isBooleanShortFlag(name string, f *flag.FlagSet) bool {
+ result := false
+ f.VisitAll(func(f *flag.Flag) {
+ if f.Shorthand == name && f.Value.Type() == "bool" {
+ result = true
+ }
+ })
+ return result
+}
+
+func stripFlags(args []string, c *Command) []string {
+ if len(args) < 1 {
+ return args
+ }
+ c.mergePersistentFlags()
+
+ commands := []string{}
+
+ inQuote := false
+ inFlag := false
+ for _, y := range args {
+ if !inQuote {
+ switch {
+ case strings.HasPrefix(y, "\""):
+ inQuote = true
+ case strings.Contains(y, "=\""):
+ inQuote = true
+ case strings.HasPrefix(y, "--") && !strings.Contains(y, "="):
+ // TODO: this isn't quite right, we should really check ahead for 'true' or 'false'
+ inFlag = !isBooleanFlag(y[2:], c.Flags())
+ case strings.HasPrefix(y, "-") && !strings.Contains(y, "=") && len(y) == 2 && !isBooleanShortFlag(y[1:], c.Flags()):
+ inFlag = true
+ case inFlag:
+ inFlag = false
+ case y == "":
+ // strip empty commands, as the go tests expect this to be ok....
+ case !strings.HasPrefix(y, "-"):
+ commands = append(commands, y)
+ inFlag = false
+ }
+ }
+
+ if strings.HasSuffix(y, "\"") && !strings.HasSuffix(y, "\\\"") {
+ inQuote = false
+ }
+ }
+
+ return commands
+}
+
+// argsMinusFirstX removes only the first x from args. Otherwise, commands that look like
+// openshift admin policy add-role-to-user admin my-user, lose the admin argument (arg[4]).
+func argsMinusFirstX(args []string, x string) []string {
+ for i, y := range args {
+ if x == y {
+ ret := []string{}
+ ret = append(ret, args[:i]...)
+ ret = append(ret, args[i+1:]...)
+ return ret
+ }
+ }
+ return args
+}
+
+// find the target command given the args and command tree
+// Meant to be run on the highest node. Only searches down.
+func (c *Command) Find(args []string) (*Command, []string, error) {
+ if c == nil {
+ return nil, nil, fmt.Errorf("Called find() on a nil Command")
+ }
+
+ var innerfind func(*Command, []string) (*Command, []string)
+
+ innerfind = func(c *Command, innerArgs []string) (*Command, []string) {
+ argsWOflags := stripFlags(innerArgs, c)
+ if len(argsWOflags) == 0 {
+ return c, innerArgs
+ }
+ nextSubCmd := argsWOflags[0]
+ matches := make([]*Command, 0)
+ for _, cmd := range c.commands {
+ if cmd.Name() == nextSubCmd || cmd.HasAlias(nextSubCmd) { // exact name or alias match
+ return innerfind(cmd, argsMinusFirstX(innerArgs, nextSubCmd))
+ }
+ if EnablePrefixMatching {
+ if strings.HasPrefix(cmd.Name(), nextSubCmd) { // prefix match
+ matches = append(matches, cmd)
+ }
+ for _, x := range cmd.Aliases {
+ if strings.HasPrefix(x, nextSubCmd) {
+ matches = append(matches, cmd)
+ }
+ }
+ }
+ }
+
+ // only accept a single prefix match - multiple matches would be ambiguous
+ if len(matches) == 1 {
+ return innerfind(matches[0], argsMinusFirstX(innerArgs, argsWOflags[0]))
+ }
+
+ return c, innerArgs
+ }
+
+ commandFound, a := innerfind(c, args)
+ argsWOflags := stripFlags(a, commandFound)
+
+ // no subcommand, always take args
+ if !commandFound.HasSubCommands() {
+ return commandFound, a, nil
+ }
+
+ // root command with subcommands, do subcommand checking
+ if commandFound == c && len(argsWOflags) > 0 {
+ suggestionsString := ""
+ if !c.DisableSuggestions {
+ if c.SuggestionsMinimumDistance <= 0 {
+ c.SuggestionsMinimumDistance = 2
+ }
+ if suggestions := c.SuggestionsFor(argsWOflags[0]); len(suggestions) > 0 {
+ suggestionsString += "\n\nDid you mean this?\n"
+ for _, s := range suggestions {
+ suggestionsString += fmt.Sprintf("\t%v\n", s)
+ }
+ }
+ }
+ return commandFound, a, fmt.Errorf("unknown command %q for %q%s", argsWOflags[0], commandFound.CommandPath(), suggestionsString)
+ }
+
+ return commandFound, a, nil
+}
+
+func (c *Command) SuggestionsFor(typedName string) []string {
+ suggestions := []string{}
+ for _, cmd := range c.commands {
+ if cmd.IsAvailableCommand() {
+ levenshteinDistance := ld(typedName, cmd.Name(), true)
+ suggestByLevenshtein := levenshteinDistance <= c.SuggestionsMinimumDistance
+ suggestByPrefix := strings.HasPrefix(strings.ToLower(cmd.Name()), strings.ToLower(typedName))
+ if suggestByLevenshtein || suggestByPrefix {
+ suggestions = append(suggestions, cmd.Name())
+ }
+ for _, explicitSuggestion := range cmd.SuggestFor {
+ if strings.EqualFold(typedName, explicitSuggestion) {
+ suggestions = append(suggestions, cmd.Name())
+ }
+ }
+ }
+ }
+ return suggestions
+}
+
+func (c *Command) VisitParents(fn func(*Command)) {
+ var traverse func(*Command) *Command
+
+ traverse = func(x *Command) *Command {
+ if x != c {
+ fn(x)
+ }
+ if x.HasParent() {
+ return traverse(x.parent)
+ }
+ return x
+ }
+ traverse(c)
+}
+
+func (c *Command) Root() *Command {
+ var findRoot func(*Command) *Command
+
+ findRoot = func(x *Command) *Command {
+ if x.HasParent() {
+ return findRoot(x.parent)
+ }
+ return x
+ }
+
+ return findRoot(c)
+}
+
+// ArgsLenAtDash will return the length of f.Args at the moment when a -- was
+// found during arg parsing. This allows your program to know which args were
+// before the -- and which came after. (Description from
+// https://godoc.org/github.com/spf13/pflag#FlagSet.ArgsLenAtDash).
+func (c *Command) ArgsLenAtDash() int {
+ return c.Flags().ArgsLenAtDash()
+}
+
+func (c *Command) execute(a []string) (err error) {
+ if c == nil {
+ return fmt.Errorf("Called Execute() on a nil Command")
+ }
+
+ if len(c.Deprecated) > 0 {
+ c.Printf("Command %q is deprecated, %s\n", c.Name(), c.Deprecated)
+ }
+
+ // initialize help flag as the last point possible to allow for user
+ // overriding
+ c.initHelpFlag()
+
+ err = c.ParseFlags(a)
+ if err != nil {
+ return err
+ }
+ // If help is called, regardless of other flags, return we want help
+ // Also say we need help if the command isn't runnable.
+ helpVal, err := c.Flags().GetBool("help")
+ if err != nil {
+ // should be impossible to get here as we always declare a help
+ // flag in initHelpFlag()
+ c.Println("\"help\" flag declared as non-bool. Please correct your code")
+ return err
+ }
+ if helpVal || !c.Runnable() {
+ return flag.ErrHelp
+ }
+
+ c.preRun()
+ argWoFlags := c.Flags().Args()
+
+ for p := c; p != nil; p = p.Parent() {
+ if p.PersistentPreRunE != nil {
+ if err := p.PersistentPreRunE(c, argWoFlags); err != nil {
+ return err
+ }
+ break
+ } else if p.PersistentPreRun != nil {
+ p.PersistentPreRun(c, argWoFlags)
+ break
+ }
+ }
+ if c.PreRunE != nil {
+ if err := c.PreRunE(c, argWoFlags); err != nil {
+ return err
+ }
+ } else if c.PreRun != nil {
+ c.PreRun(c, argWoFlags)
+ }
+
+ if c.RunE != nil {
+ if err := c.RunE(c, argWoFlags); err != nil {
+ return err
+ }
+ } else {
+ c.Run(c, argWoFlags)
+ }
+ if c.PostRunE != nil {
+ if err := c.PostRunE(c, argWoFlags); err != nil {
+ return err
+ }
+ } else if c.PostRun != nil {
+ c.PostRun(c, argWoFlags)
+ }
+ for p := c; p != nil; p = p.Parent() {
+ if p.PersistentPostRunE != nil {
+ if err := p.PersistentPostRunE(c, argWoFlags); err != nil {
+ return err
+ }
+ break
+ } else if p.PersistentPostRun != nil {
+ p.PersistentPostRun(c, argWoFlags)
+ break
+ }
+ }
+
+ return nil
+}
+
+func (c *Command) preRun() {
+ for _, x := range initializers {
+ x()
+ }
+}
+
+func (c *Command) errorMsgFromParse() string {
+ s := c.flagErrorBuf.String()
+
+ x := strings.Split(s, "\n")
+
+ if len(x) > 0 {
+ return x[0]
+ } else {
+ return ""
+ }
+}
+
+// Call execute to use the args (os.Args[1:] by default)
+// and run through the command tree finding appropriate matches
+// for commands and then corresponding flags.
+func (c *Command) Execute() error {
+ _, err := c.ExecuteC()
+ return err
+}
+
+func (c *Command) ExecuteC() (cmd *Command, err error) {
+
+ // Regardless of what command execute is called on, run on Root only
+ if c.HasParent() {
+ return c.Root().ExecuteC()
+ }
+
+ // windows hook
+ if preExecHookFn != nil {
+ preExecHookFn(c)
+ }
+
+ // initialize help as the last point possible to allow for user
+ // overriding
+ c.initHelpCmd()
+
+ var args []string
+
+ // Workaround FAIL with "go test -v" or "cobra.test -test.v", see #155
+ if c.args == nil && filepath.Base(os.Args[0]) != "cobra.test" {
+ args = os.Args[1:]
+ } else {
+ args = c.args
+ }
+
+ cmd, flags, err := c.Find(args)
+ if err != nil {
+ // If found parse to a subcommand and then failed, talk about the subcommand
+ if cmd != nil {
+ c = cmd
+ }
+ if !c.SilenceErrors {
+ c.Println("Error:", err.Error())
+ c.Printf("Run '%v --help' for usage.\n", c.CommandPath())
+ }
+ return c, err
+ }
+ err = cmd.execute(flags)
+ if err != nil {
+ // Always show help if requested, even if SilenceErrors is in
+ // effect
+ if err == flag.ErrHelp {
+ cmd.HelpFunc()(cmd, args)
+ return cmd, nil
+ }
+
+ // If root command has SilentErrors flagged,
+ // all subcommands should respect it
+ if !cmd.SilenceErrors && !c.SilenceErrors {
+ c.Println("Error:", err.Error())
+ }
+
+ // If root command has SilentUsage flagged,
+ // all subcommands should respect it
+ if !cmd.SilenceUsage && !c.SilenceUsage {
+ c.Println(cmd.UsageString())
+ }
+ return cmd, err
+ }
+ return cmd, nil
+}
+
+func (c *Command) initHelpFlag() {
+ if c.Flags().Lookup("help") == nil {
+ c.Flags().BoolP("help", "h", false, "help for "+c.Name())
+ }
+}
+
+func (c *Command) initHelpCmd() {
+ if c.helpCommand == nil {
+ if !c.HasSubCommands() {
+ return
+ }
+
+ c.helpCommand = &Command{
+ Use: "help [command]",
+ Short: "Help about any command",
+ Long: `Help provides help for any command in the application.
+ Simply type ` + c.Name() + ` help [path to command] for full details.`,
+ PersistentPreRun: func(cmd *Command, args []string) {},
+ PersistentPostRun: func(cmd *Command, args []string) {},
+
+ Run: func(c *Command, args []string) {
+ cmd, _, e := c.Root().Find(args)
+ if cmd == nil || e != nil {
+ c.Printf("Unknown help topic %#q.", args)
+ c.Root().Usage()
+ } else {
+ helpFunc := cmd.HelpFunc()
+ helpFunc(cmd, args)
+ }
+ },
+ }
+ }
+ c.AddCommand(c.helpCommand)
+}
+
+// Used for testing
+func (c *Command) ResetCommands() {
+ c.commands = nil
+ c.helpCommand = nil
+}
+
+//Commands returns a slice of child commands.
+func (c *Command) Commands() []*Command {
+ return c.commands
+}
+
+// AddCommand adds one or more commands to this parent command.
+func (c *Command) AddCommand(cmds ...*Command) {
+ for i, x := range cmds {
+ if cmds[i] == c {
+ panic("Command can't be a child of itself")
+ }
+ cmds[i].parent = c
+ // update max lengths
+ usageLen := len(x.Use)
+ if usageLen > c.commandsMaxUseLen {
+ c.commandsMaxUseLen = usageLen
+ }
+ commandPathLen := len(x.CommandPath())
+ if commandPathLen > c.commandsMaxCommandPathLen {
+ c.commandsMaxCommandPathLen = commandPathLen
+ }
+ nameLen := len(x.Name())
+ if nameLen > c.commandsMaxNameLen {
+ c.commandsMaxNameLen = nameLen
+ }
+ // If global normalization function exists, update all children
+ if c.globNormFunc != nil {
+ x.SetGlobalNormalizationFunc(c.globNormFunc)
+ }
+ c.commands = append(c.commands, x)
+ }
+}
+
+// AddCommand removes one or more commands from a parent command.
+func (c *Command) RemoveCommand(cmds ...*Command) {
+ commands := []*Command{}
+main:
+ for _, command := range c.commands {
+ for _, cmd := range cmds {
+ if command == cmd {
+ command.parent = nil
+ continue main
+ }
+ }
+ commands = append(commands, command)
+ }
+ c.commands = commands
+ // recompute all lengths
+ c.commandsMaxUseLen = 0
+ c.commandsMaxCommandPathLen = 0
+ c.commandsMaxNameLen = 0
+ for _, command := range c.commands {
+ usageLen := len(command.Use)
+ if usageLen > c.commandsMaxUseLen {
+ c.commandsMaxUseLen = usageLen
+ }
+ commandPathLen := len(command.CommandPath())
+ if commandPathLen > c.commandsMaxCommandPathLen {
+ c.commandsMaxCommandPathLen = commandPathLen
+ }
+ nameLen := len(command.Name())
+ if nameLen > c.commandsMaxNameLen {
+ c.commandsMaxNameLen = nameLen
+ }
+ }
+}
+
+// Convenience method to Print to the defined output
+func (c *Command) Print(i ...interface{}) {
+ fmt.Fprint(c.Out(), i...)
+}
+
+// Convenience method to Println to the defined output
+func (c *Command) Println(i ...interface{}) {
+ str := fmt.Sprintln(i...)
+ c.Print(str)
+}
+
+// Convenience method to Printf to the defined output
+func (c *Command) Printf(format string, i ...interface{}) {
+ str := fmt.Sprintf(format, i...)
+ c.Print(str)
+}
+
+// Output the usage for the command
+// Used when a user provides invalid input
+// Can be defined by user by overriding UsageFunc
+func (c *Command) Usage() error {
+ c.mergePersistentFlags()
+ err := c.UsageFunc()(c)
+ return err
+}
+
+// Output the help for the command
+// Used when a user calls help [command]
+// by the default HelpFunc in the commander
+func (c *Command) Help() error {
+ c.mergePersistentFlags()
+ err := tmpl(c.getOutOrStdout(), c.HelpTemplate(), c)
+ return err
+}
+
+func (c *Command) UsageString() string {
+ tmpOutput := c.output
+ bb := new(bytes.Buffer)
+ c.SetOutput(bb)
+ c.Usage()
+ c.output = tmpOutput
+ return bb.String()
+}
+
+// CommandPath returns the full path to this command.
+func (c *Command) CommandPath() string {
+ str := c.Name()
+ x := c
+ for x.HasParent() {
+ str = x.parent.Name() + " " + str
+ x = x.parent
+ }
+ return str
+}
+
+//The full usage for a given command (including parents)
+func (c *Command) UseLine() string {
+ str := ""
+ if c.HasParent() {
+ str = c.parent.CommandPath() + " "
+ }
+ return str + c.Use
+}
+
+// For use in determining which flags have been assigned to which commands
+// and which persist
+func (c *Command) DebugFlags() {
+ c.Println("DebugFlags called on", c.Name())
+ var debugflags func(*Command)
+
+ debugflags = func(x *Command) {
+ if x.HasFlags() || x.HasPersistentFlags() {
+ c.Println(x.Name())
+ }
+ if x.HasFlags() {
+ x.flags.VisitAll(func(f *flag.Flag) {
+ if x.HasPersistentFlags() {
+ if x.persistentFlag(f.Name) == nil {
+ c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]")
+ } else {
+ c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [LP]")
+ }
+ } else {
+ c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [L]")
+ }
+ })
+ }
+ if x.HasPersistentFlags() {
+ x.pflags.VisitAll(func(f *flag.Flag) {
+ if x.HasFlags() {
+ if x.flags.Lookup(f.Name) == nil {
+ c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]")
+ }
+ } else {
+ c.Println(" -"+f.Shorthand+",", "--"+f.Name, "["+f.DefValue+"]", "", f.Value, " [P]")
+ }
+ })
+ }
+ c.Println(x.flagErrorBuf)
+ if x.HasSubCommands() {
+ for _, y := range x.commands {
+ debugflags(y)
+ }
+ }
+ }
+
+ debugflags(c)
+}
+
+// Name returns the command's name: the first word in the use line.
+func (c *Command) Name() string {
+ if c.name != "" {
+ return c.name
+ }
+ name := c.Use
+ i := strings.Index(name, " ")
+ if i >= 0 {
+ name = name[:i]
+ }
+ return name
+}
+
+// Determine if a given string is an alias of the command.
+func (c *Command) HasAlias(s string) bool {
+ for _, a := range c.Aliases {
+ if a == s {
+ return true
+ }
+ }
+ return false
+}
+
+func (c *Command) NameAndAliases() string {
+ return strings.Join(append([]string{c.Name()}, c.Aliases...), ", ")
+}
+
+func (c *Command) HasExample() bool {
+ return len(c.Example) > 0
+}
+
+// Determine if the command is itself runnable
+func (c *Command) Runnable() bool {
+ return c.Run != nil || c.RunE != nil
+}
+
+// Determine if the command has children commands
+func (c *Command) HasSubCommands() bool {
+ return len(c.commands) > 0
+}
+
+// IsAvailableCommand determines if a command is available as a non-help command
+// (this includes all non deprecated/hidden commands)
+func (c *Command) IsAvailableCommand() bool {
+ if len(c.Deprecated) != 0 || c.Hidden {
+ return false
+ }
+
+ if c.HasParent() && c.Parent().helpCommand == c {
+ return false
+ }
+
+ if c.Runnable() || c.HasAvailableSubCommands() {
+ return true
+ }
+
+ return false
+}
+
+// IsHelpCommand determines if a command is a 'help' command; a help command is
+// determined by the fact that it is NOT runnable/hidden/deprecated, and has no
+// sub commands that are runnable/hidden/deprecated
+func (c *Command) IsHelpCommand() bool {
+
+ // if a command is runnable, deprecated, or hidden it is not a 'help' command
+ if c.Runnable() || len(c.Deprecated) != 0 || c.Hidden {
+ return false
+ }
+
+ // if any non-help sub commands are found, the command is not a 'help' command
+ for _, sub := range c.commands {
+ if !sub.IsHelpCommand() {
+ return false
+ }
+ }
+
+ // the command either has no sub commands, or no non-help sub commands
+ return true
+}
+
+// HasHelpSubCommands determines if a command has any avilable 'help' sub commands
+// that need to be shown in the usage/help default template under 'additional help
+// topics'
+func (c *Command) HasHelpSubCommands() bool {
+
+ // return true on the first found available 'help' sub command
+ for _, sub := range c.commands {
+ if sub.IsHelpCommand() {
+ return true
+ }
+ }
+
+ // the command either has no sub commands, or no available 'help' sub commands
+ return false
+}
+
+// HasAvailableSubCommands determines if a command has available sub commands that
+// need to be shown in the usage/help default template under 'available commands'
+func (c *Command) HasAvailableSubCommands() bool {
+
+ // return true on the first found available (non deprecated/help/hidden)
+ // sub command
+ for _, sub := range c.commands {
+ if sub.IsAvailableCommand() {
+ return true
+ }
+ }
+
+ // the command either has no sub comamnds, or no available (non deprecated/help/hidden)
+ // sub commands
+ return false
+}
+
+// Determine if the command is a child command
+func (c *Command) HasParent() bool {
+ return c.parent != nil
+}
+
+// GlobalNormalizationFunc returns the global normalization function or nil if doesn't exists
+func (c *Command) GlobalNormalizationFunc() func(f *flag.FlagSet, name string) flag.NormalizedName {
+ return c.globNormFunc
+}
+
+// Get the complete FlagSet that applies to this command (local and persistent declared here and by all parents)
+func (c *Command) Flags() *flag.FlagSet {
+ if c.flags == nil {
+ c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ if c.flagErrorBuf == nil {
+ c.flagErrorBuf = new(bytes.Buffer)
+ }
+ c.flags.SetOutput(c.flagErrorBuf)
+ }
+ return c.flags
+}
+
+// Get the local FlagSet specifically set in the current command
+func (c *Command) LocalFlags() *flag.FlagSet {
+ c.mergePersistentFlags()
+
+ local := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ c.lflags.VisitAll(func(f *flag.Flag) {
+ local.AddFlag(f)
+ })
+ if !c.HasParent() {
+ flag.CommandLine.VisitAll(func(f *flag.Flag) {
+ if local.Lookup(f.Name) == nil {
+ local.AddFlag(f)
+ }
+ })
+ }
+ return local
+}
+
+// All Flags which were inherited from parents commands
+func (c *Command) InheritedFlags() *flag.FlagSet {
+ c.mergePersistentFlags()
+
+ inherited := flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ local := c.LocalFlags()
+
+ var rmerge func(x *Command)
+
+ rmerge = func(x *Command) {
+ if x.HasPersistentFlags() {
+ x.PersistentFlags().VisitAll(func(f *flag.Flag) {
+ if inherited.Lookup(f.Name) == nil && local.Lookup(f.Name) == nil {
+ inherited.AddFlag(f)
+ }
+ })
+ }
+ if x.HasParent() {
+ rmerge(x.parent)
+ }
+ }
+
+ if c.HasParent() {
+ rmerge(c.parent)
+ }
+
+ return inherited
+}
+
+// All Flags which were not inherited from parent commands
+func (c *Command) NonInheritedFlags() *flag.FlagSet {
+ return c.LocalFlags()
+}
+
+// Get the Persistent FlagSet specifically set in the current command
+func (c *Command) PersistentFlags() *flag.FlagSet {
+ if c.pflags == nil {
+ c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ if c.flagErrorBuf == nil {
+ c.flagErrorBuf = new(bytes.Buffer)
+ }
+ c.pflags.SetOutput(c.flagErrorBuf)
+ }
+ return c.pflags
+}
+
+// For use in testing
+func (c *Command) ResetFlags() {
+ c.flagErrorBuf = new(bytes.Buffer)
+ c.flagErrorBuf.Reset()
+ c.flags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ c.flags.SetOutput(c.flagErrorBuf)
+ c.pflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ c.pflags.SetOutput(c.flagErrorBuf)
+}
+
+// Does the command contain any flags (local plus persistent from the entire structure)
+func (c *Command) HasFlags() bool {
+ return c.Flags().HasFlags()
+}
+
+// Does the command contain persistent flags
+func (c *Command) HasPersistentFlags() bool {
+ return c.PersistentFlags().HasFlags()
+}
+
+// Does the command has flags specifically declared locally
+func (c *Command) HasLocalFlags() bool {
+ return c.LocalFlags().HasFlags()
+}
+
+func (c *Command) HasInheritedFlags() bool {
+ return c.InheritedFlags().HasFlags()
+}
+
+// Climbs up the command tree looking for matching flag
+func (c *Command) Flag(name string) (flag *flag.Flag) {
+ flag = c.Flags().Lookup(name)
+
+ if flag == nil {
+ flag = c.persistentFlag(name)
+ }
+
+ return
+}
+
+// recursively find matching persistent flag
+func (c *Command) persistentFlag(name string) (flag *flag.Flag) {
+ if c.HasPersistentFlags() {
+ flag = c.PersistentFlags().Lookup(name)
+ }
+
+ if flag == nil && c.HasParent() {
+ flag = c.parent.persistentFlag(name)
+ }
+ return
+}
+
+// Parses persistent flag tree & local flags
+func (c *Command) ParseFlags(args []string) (err error) {
+ c.mergePersistentFlags()
+ err = c.Flags().Parse(args)
+ return
+}
+
+func (c *Command) Parent() *Command {
+ return c.parent
+}
+
+func (c *Command) mergePersistentFlags() {
+ var rmerge func(x *Command)
+
+ // Save the set of local flags
+ if c.lflags == nil {
+ c.lflags = flag.NewFlagSet(c.Name(), flag.ContinueOnError)
+ if c.flagErrorBuf == nil {
+ c.flagErrorBuf = new(bytes.Buffer)
+ }
+ c.lflags.SetOutput(c.flagErrorBuf)
+ addtolocal := func(f *flag.Flag) {
+ c.lflags.AddFlag(f)
+ }
+ c.Flags().VisitAll(addtolocal)
+ c.PersistentFlags().VisitAll(addtolocal)
+ }
+ rmerge = func(x *Command) {
+ if !x.HasParent() {
+ flag.CommandLine.VisitAll(func(f *flag.Flag) {
+ if x.PersistentFlags().Lookup(f.Name) == nil {
+ x.PersistentFlags().AddFlag(f)
+ }
+ })
+ }
+ if x.HasPersistentFlags() {
+ x.PersistentFlags().VisitAll(func(f *flag.Flag) {
+ if c.Flags().Lookup(f.Name) == nil {
+ c.Flags().AddFlag(f)
+ }
+ })
+ }
+ if x.HasParent() {
+ rmerge(x.parent)
+ }
+ }
+
+ rmerge(c)
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_notwin.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_notwin.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_notwin.go
new file mode 100644
index 0000000..073dd35
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_notwin.go
@@ -0,0 +1,5 @@
+// +build !windows
+
+package cobra
+
+var preExecHookFn func(*Command) = nil
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_test.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_test.go
new file mode 100644
index 0000000..43ed7a3
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_test.go
@@ -0,0 +1,114 @@
+package cobra
+
+import (
+ "reflect"
+ "testing"
+)
+
+// test to ensure hidden commands run as intended
+func TestHiddenCommandExecutes(t *testing.T) {
+
+ // ensure that outs does not already equal what the command will be setting it
+ // to, if it did this test would not actually be testing anything...
+ if outs == "hidden" {
+ t.Errorf("outs should NOT EQUAL hidden")
+ }
+
+ cmdHidden.Execute()
+
+ // upon running the command, the value of outs should now be 'hidden'
+ if outs != "hidden" {
+ t.Errorf("Hidden command failed to run!")
+ }
+}
+
+// test to ensure hidden commands do not show up in usage/help text
+func TestHiddenCommandIsHidden(t *testing.T) {
+ if cmdHidden.IsAvailableCommand() {
+ t.Errorf("Hidden command found!")
+ }
+}
+
+func TestStripFlags(t *testing.T) {
+ tests := []struct {
+ input []string
+ output []string
+ }{
+ {
+ []string{"foo", "bar"},
+ []string{"foo", "bar"},
+ },
+ {
+ []string{"foo", "--bar", "-b"},
+ []string{"foo"},
+ },
+ {
+ []string{"-b", "foo", "--bar", "bar"},
+ []string{},
+ },
+ {
+ []string{"-i10", "echo"},
+ []string{"echo"},
+ },
+ {
+ []string{"-i=10", "echo"},
+ []string{"echo"},
+ },
+ {
+ []string{"--int=100", "echo"},
+ []string{"echo"},
+ },
+ {
+ []string{"-ib", "echo", "-bfoo", "baz"},
+ []string{"echo", "baz"},
+ },
+ {
+ []string{"-i=baz", "bar", "-i", "foo", "blah"},
+ []string{"bar", "blah"},
+ },
+ {
+ []string{"--int=baz", "-bbar", "-i", "foo", "blah"},
+ []string{"blah"},
+ },
+ {
+ []string{"--cat", "bar", "-i", "foo", "blah"},
+ []string{"bar", "blah"},
+ },
+ {
+ []string{"-c", "bar", "-i", "foo", "blah"},
+ []string{"bar", "blah"},
+ },
+ {
+ []string{"--persist", "bar"},
+ []string{"bar"},
+ },
+ {
+ []string{"-p", "bar"},
+ []string{"bar"},
+ },
+ }
+
+ cmdPrint := &Command{
+ Use: "print [string to print]",
+ Short: "Print anything to the screen",
+ Long: `an utterly useless command for testing.`,
+ Run: func(cmd *Command, args []string) {
+ tp = args
+ },
+ }
+
+ var flagi int
+ var flagstr string
+ var flagbool bool
+ cmdPrint.PersistentFlags().BoolVarP(&flagbool, "persist", "p", false, "help for persistent one")
+ cmdPrint.Flags().IntVarP(&flagi, "int", "i", 345, "help message for flag int")
+ cmdPrint.Flags().StringVarP(&flagstr, "bar", "b", "bar", "help message for flag string")
+ cmdPrint.Flags().BoolVarP(&flagbool, "cat", "c", false, "help message for flag bool")
+
+ for _, test := range tests {
+ output := stripFlags(test.input, cmdPrint)
+ if !reflect.DeepEqual(test.output, output) {
+ t.Errorf("expected: %v, got: %v", test.output, output)
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_win.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_win.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_win.go
new file mode 100644
index 0000000..4b0eaa1
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_win.go
@@ -0,0 +1,26 @@
+// +build windows
+
+package cobra
+
+import (
+ "os"
+ "time"
+
+ "github.com/inconshreveable/mousetrap"
+)
+
+var preExecHookFn = preExecHook
+
+// enables an information splash screen on Windows if the CLI is started from explorer.exe.
+var MousetrapHelpText string = `This is a command line tool
+
+You need to open cmd.exe and run it from there.
+`
+
+func preExecHook(c *Command) {
+ if mousetrap.StartedByExplorer() {
+ c.Print(MousetrapHelpText)
+ time.Sleep(5 * time.Second)
+ os.Exit(1)
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/cmd_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/cmd_test.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/cmd_test.go
new file mode 100644
index 0000000..a4b5568
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/cmd_test.go
@@ -0,0 +1,145 @@
+package doc
+
+import (
+ "bytes"
+ "fmt"
+ "runtime"
+ "strings"
+ "testing"
+
+ "github.com/spf13/cobra"
+)
+
+var flagb1, flagb2, flagb3, flagbr, flagbp bool
+var flags1, flags2a, flags2b, flags3 string
+var flagi1, flagi2, flagi3, flagir int
+
+const strtwoParentHelp = "help message for parent flag strtwo"
+const strtwoChildHelp = "help message for child flag strtwo"
+
+var cmdEcho = &cobra.Command{
+ Use: "echo [string to echo]",
+ Aliases: []string{"say"},
+ Short: "Echo anything to the screen",
+ Long: `an utterly useless command for testing.`,
+ Example: "Just run cobra-test echo",
+}
+
+var cmdEchoSub = &cobra.Command{
+ Use: "echosub [string to print]",
+ Short: "second sub command for echo",
+ Long: `an absolutely utterly useless command for testing gendocs!.`,
+ Run: func(cmd *cobra.Command, args []string) {},
+}
+
+var cmdDeprecated = &cobra.Command{
+ Use: "deprecated [can't do anything here]",
+ Short: "A command which is deprecated",
+ Long: `an absolutely utterly useless command for testing deprecation!.`,
+ Deprecated: "Please use echo instead",
+}
+
+var cmdTimes = &cobra.Command{
+ Use: "times [# times] [string to echo]",
+ SuggestFor: []string{"counts"},
+ Short: "Echo anything to the screen more times",
+ Long: `a slightly useless command for testing.`,
+ PersistentPreRun: func(cmd *cobra.Command, args []string) {},
+ Run: func(cmd *cobra.Command, args []string) {},
+}
+
+var cmdPrint = &cobra.Command{
+ Use: "print [string to print]",
+ Short: "Print anything to the screen",
+ Long: `an absolutely utterly useless command for testing.`,
+}
+
+var cmdRootNoRun = &cobra.Command{
+ Use: "cobra-test",
+ Short: "The root can run its own function",
+ Long: "The root description for help",
+}
+
+var cmdRootSameName = &cobra.Command{
+ Use: "print",
+ Short: "Root with the same name as a subcommand",
+ Long: "The root description for help",
+}
+
+var cmdRootWithRun = &cobra.Command{
+ Use: "cobra-test",
+ Short: "The root can run its own function",
+ Long: "The root description for help",
+}
+
+var cmdSubNoRun = &cobra.Command{
+ Use: "subnorun",
+ Short: "A subcommand without a Run function",
+ Long: "A long output about a subcommand without a Run function",
+}
+
+var cmdVersion1 = &cobra.Command{
+ Use: "version",
+ Short: "Print the version number",
+ Long: `First version of the version command`,
+}
+
+var cmdVersion2 = &cobra.Command{
+ Use: "version",
+ Short: "Print the version number",
+ Long: `Second version of the version command`,
+}
+
+func flagInit() {
+ cmdEcho.ResetFlags()
+ cmdPrint.ResetFlags()
+ cmdTimes.ResetFlags()
+ cmdRootNoRun.ResetFlags()
+ cmdRootSameName.ResetFlags()
+ cmdRootWithRun.ResetFlags()
+ cmdSubNoRun.ResetFlags()
+ cmdRootNoRun.PersistentFlags().StringVarP(&flags2a, "strtwo", "t", "two", strtwoParentHelp)
+ cmdEcho.Flags().IntVarP(&flagi1, "intone", "i", 123, "help message for flag intone")
+ cmdTimes.Flags().IntVarP(&flagi2, "inttwo", "j", 234, "help message for flag inttwo")
+ cmdPrint.Flags().IntVarP(&flagi3, "intthree", "i", 345, "help message for flag intthree")
+ cmdEcho.PersistentFlags().StringVarP(&flags1, "strone", "s", "one", "help message for flag strone")
+ cmdEcho.PersistentFlags().BoolVarP(&flagbp, "persistentbool", "p", false, "help message for flag persistentbool")
+ cmdTimes.PersistentFlags().StringVarP(&flags2b, "strtwo", "t", "2", strtwoChildHelp)
+ cmdPrint.PersistentFlags().StringVarP(&flags3, "strthree", "s", "three", "help message for flag strthree")
+ cmdEcho.Flags().BoolVarP(&flagb1, "boolone", "b", true, "help message for flag boolone")
+ cmdTimes.Flags().BoolVarP(&flagb2, "booltwo", "c", false, "help message for flag booltwo")
+ cmdPrint.Flags().BoolVarP(&flagb3, "boolthree", "b", true, "help message for flag boolthree")
+ cmdVersion1.ResetFlags()
+ cmdVersion2.ResetFlags()
+}
+
+func initializeWithRootCmd() *cobra.Command {
+ cmdRootWithRun.ResetCommands()
+ flagInit()
+ cmdRootWithRun.Flags().BoolVarP(&flagbr, "boolroot", "b", false, "help message for flag boolroot")
+ cmdRootWithRun.Flags().IntVarP(&flagir, "introot", "i", 321, "help message for flag introot")
+ return cmdRootWithRun
+}
+
+func checkStringContains(t *testing.T, found, expected string) {
+ if !strings.Contains(found, expected) {
+ logErr(t, found, expected)
+ }
+}
+
+func checkStringOmits(t *testing.T, found, expected string) {
+ if strings.Contains(found, expected) {
+ logErr(t, found, expected)
+ }
+}
+
+func logErr(t *testing.T, found, expected string) {
+ out := new(bytes.Buffer)
+
+ _, _, line, ok := runtime.Caller(2)
+ if ok {
+ fmt.Fprintf(out, "Line: %d ", line)
+ }
+ fmt.Fprintf(out, "Unexpected response.\nExpecting to contain: \n %q\nGot:\n %q\n", expected, found)
+ t.Errorf(out.String())
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.go
new file mode 100644
index 0000000..f21d839
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.go
@@ -0,0 +1,218 @@
+// Copyright 2015 Red Hat Inc. All rights reserved.
+//
+// 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.
+
+package doc
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "sort"
+ "strings"
+ "time"
+
+ mangen "github.com/cpuguy83/go-md2man/md2man"
+ "github.com/spf13/cobra"
+ "github.com/spf13/pflag"
+)
+
+// GenManTree will generate a man page for this command and all decendants
+// in the directory given. The header may be nil. This function may not work
+// correctly if your command names have - in them. If you have `cmd` with two
+// subcmds, `sub` and `sub-third`. And `sub` has a subcommand called `third`
+// it is undefined which help output will be in the file `cmd-sub-third.1`.
+func GenManTree(cmd *cobra.Command, header *GenManHeader, dir string) error {
+ if header == nil {
+ header = &GenManHeader{}
+ }
+ for _, c := range cmd.Commands() {
+ if !c.IsAvailableCommand() || c.IsHelpCommand() {
+ continue
+ }
+ if err := GenManTree(c, header, dir); err != nil {
+ return err
+ }
+ }
+ needToResetTitle := header.Title == ""
+
+ basename := strings.Replace(cmd.CommandPath(), " ", "_", -1) + ".1"
+ filename := filepath.Join(dir, basename)
+ f, err := os.Create(filename)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ if err := GenMan(cmd, header, f); err != nil {
+ return err
+ }
+
+ if needToResetTitle {
+ header.Title = ""
+ }
+ return nil
+}
+
+// GenManHeader is a lot like the .TH header at the start of man pages. These
+// include the title, section, date, source, and manual. We will use the
+// current time if Date if unset and will use "Auto generated by spf13/cobra"
+// if the Source is unset.
+type GenManHeader struct {
+ Title string
+ Section string
+ Date *time.Time
+ date string
+ Source string
+ Manual string
+}
+
+// GenMan will generate a man page for the given command and write it to
+// w. The header argument may be nil, however obviously w may not.
+func GenMan(cmd *cobra.Command, header *GenManHeader, w io.Writer) error {
+ if header == nil {
+ header = &GenManHeader{}
+ }
+ b := genMan(cmd, header)
+ final := mangen.Render(b)
+ _, err := w.Write(final)
+ return err
+}
+
+func fillHeader(header *GenManHeader, name string) {
+ if header.Title == "" {
+ header.Title = strings.ToUpper(strings.Replace(name, " ", "\\-", -1))
+ }
+ if header.Section == "" {
+ header.Section = "1"
+ }
+ if header.Date == nil {
+ now := time.Now()
+ header.Date = &now
+ }
+ header.date = (*header.Date).Format("Jan 2006")
+ if header.Source == "" {
+ header.Source = "Auto generated by spf13/cobra"
+ }
+}
+
+func manPreamble(out io.Writer, header *GenManHeader, name, short, long string) {
+ dashName := strings.Replace(name, " ", "-", -1)
+ fmt.Fprintf(out, `%% %s(%s)%s
+%% %s
+%% %s
+# NAME
+`, header.Title, header.Section, header.date, header.Source, header.Manual)
+ fmt.Fprintf(out, "%s \\- %s\n\n", dashName, short)
+ fmt.Fprintf(out, "# SYNOPSIS\n")
+ fmt.Fprintf(out, "**%s** [OPTIONS]\n\n", name)
+ fmt.Fprintf(out, "# DESCRIPTION\n")
+ fmt.Fprintf(out, "%s\n\n", long)
+}
+
+func manPrintFlags(out io.Writer, flags *pflag.FlagSet) {
+ flags.VisitAll(func(flag *pflag.Flag) {
+ if len(flag.Deprecated) > 0 || flag.Hidden {
+ return
+ }
+ format := ""
+ if len(flag.Shorthand) > 0 {
+ format = "**-%s**, **--%s**"
+ } else {
+ format = "%s**--%s**"
+ }
+ if len(flag.NoOptDefVal) > 0 {
+ format = format + "["
+ }
+ if flag.Value.Type() == "string" {
+ // put quotes on the value
+ format = format + "=%q"
+ } else {
+ format = format + "=%s"
+ }
+ if len(flag.NoOptDefVal) > 0 {
+ format = format + "]"
+ }
+ format = format + "\n\t%s\n\n"
+ fmt.Fprintf(out, format, flag.Shorthand, flag.Name, flag.DefValue, flag.Usage)
+ })
+}
+
+func manPrintOptions(out io.Writer, command *cobra.Command) {
+ flags := command.NonInheritedFlags()
+ if flags.HasFlags() {
+ fmt.Fprintf(out, "# OPTIONS\n")
+ manPrintFlags(out, flags)
+ fmt.Fprintf(out, "\n")
+ }
+ flags = command.InheritedFlags()
+ if flags.HasFlags() {
+ fmt.Fprintf(out, "# OPTIONS INHERITED FROM PARENT COMMANDS\n")
+ manPrintFlags(out, flags)
+ fmt.Fprintf(out, "\n")
+ }
+}
+
+func genMan(cmd *cobra.Command, header *GenManHeader) []byte {
+ // something like `rootcmd subcmd1 subcmd2`
+ commandName := cmd.CommandPath()
+ // something like `rootcmd-subcmd1-subcmd2`
+ dashCommandName := strings.Replace(commandName, " ", "-", -1)
+
+ fillHeader(header, commandName)
+
+ buf := new(bytes.Buffer)
+
+ short := cmd.Short
+ long := cmd.Long
+ if len(long) == 0 {
+ long = short
+ }
+
+ manPreamble(buf, header, commandName, short, long)
+ manPrintOptions(buf, cmd)
+ if len(cmd.Example) > 0 {
+ fmt.Fprintf(buf, "# EXAMPLE\n")
+ fmt.Fprintf(buf, "```\n%s\n```\n", cmd.Example)
+ }
+ if hasSeeAlso(cmd) {
+ fmt.Fprintf(buf, "# SEE ALSO\n")
+ if cmd.HasParent() {
+ parentPath := cmd.Parent().CommandPath()
+ dashParentPath := strings.Replace(parentPath, " ", "-", -1)
+ fmt.Fprintf(buf, "**%s(%s)**", dashParentPath, header.Section)
+ cmd.VisitParents(func(c *cobra.Command) {
+ if c.DisableAutoGenTag {
+ cmd.DisableAutoGenTag = c.DisableAutoGenTag
+ }
+ })
+ }
+ children := cmd.Commands()
+ sort.Sort(byName(children))
+ for i, c := range children {
+ if !c.IsAvailableCommand() || c.IsHelpCommand() {
+ continue
+ }
+ if cmd.HasParent() || i > 0 {
+ fmt.Fprintf(buf, ", ")
+ }
+ fmt.Fprintf(buf, "**%s-%s(%s)**", dashCommandName, c.Name(), header.Section)
+ }
+ fmt.Fprintf(buf, "\n")
+ }
+ if !cmd.DisableAutoGenTag {
+ fmt.Fprintf(buf, "# HISTORY\n%s Auto generated by spf13/cobra\n", header.Date.Format("2-Jan-2006"))
+ }
+ return buf.Bytes()
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.md
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.md b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.md
new file mode 100644
index 0000000..5fe957a
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.md
@@ -0,0 +1,26 @@
+# Generating Man Pages For Your Own cobra.Command
+
+Generating man pages from a cobra command is incredibly easy. An example is as follows:
+
+```go
+package main
+
+import (
+ "github.com/spf13/cobra"
+ "github.com/spf13/cobra/doc"
+)
+
+func main() {
+ cmd := &cobra.Command{
+ Use: "test",
+ Short: "my test program",
+ }
+ header := &cobra.GenManHeader{
+ Title: "MINE",
+ Section: "3",
+ }
+ doc.GenManTree(cmd, header, "/tmp")
+}
+```
+
+That will get you a man page `/tmp/test.1`
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs_test.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs_test.go
new file mode 100644
index 0000000..3083125
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs_test.go
@@ -0,0 +1,97 @@
+package doc
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "strings"
+ "testing"
+)
+
+var _ = fmt.Println
+var _ = os.Stderr
+
+func translate(in string) string {
+ return strings.Replace(in, "-", "\\-", -1)
+}
+
+func TestGenManDoc(t *testing.T) {
+ c := initializeWithRootCmd()
+ // Need two commands to run the command alphabetical sort
+ cmdEcho.AddCommand(cmdTimes, cmdEchoSub, cmdDeprecated)
+ c.AddCommand(cmdPrint, cmdEcho)
+ cmdRootWithRun.PersistentFlags().StringVarP(&flags2a, "rootflag", "r", "two", strtwoParentHelp)
+
+ out := new(bytes.Buffer)
+
+ header := &GenManHeader{
+ Title: "Project",
+ Section: "2",
+ }
+ // We generate on a subcommand so we have both subcommands and parents
+ if err := GenMan(cmdEcho, header, out); err != nil {
+ t.Fatal(err)
+ }
+ found := out.String()
+
+ // Make sure parent has - in CommandPath() in SEE ALSO:
+ parentPath := cmdEcho.Parent().CommandPath()
+ dashParentPath := strings.Replace(parentPath, " ", "-", -1)
+ expected := translate(dashParentPath)
+ expected = expected + "(" + header.Section + ")"
+ checkStringContains(t, found, expected)
+
+ // Our description
+ expected = translate(cmdEcho.Name())
+ checkStringContains(t, found, expected)
+
+ // Better have our example
+ expected = translate(cmdEcho.Name())
+ checkStringContains(t, found, expected)
+
+ // A local flag
+ expected = "boolone"
+ checkStringContains(t, found, expected)
+
+ // persistent flag on parent
+ expected = "rootflag"
+ checkStringContains(t, found, expected)
+
+ // We better output info about our parent
+ expected = translate(cmdRootWithRun.Name())
+ checkStringContains(t, found, expected)
+
+ // And about subcommands
+ expected = translate(cmdEchoSub.Name())
+ checkStringContains(t, found, expected)
+
+ unexpected := translate(cmdDeprecated.Name())
+ checkStringOmits(t, found, unexpected)
+
+ // auto generated
+ expected = translate("Auto generated")
+ checkStringContains(t, found, expected)
+}
+
+func TestGenManNoGenTag(t *testing.T) {
+ c := initializeWithRootCmd()
+ // Need two commands to run the command alphabetical sort
+ cmdEcho.AddCommand(cmdTimes, cmdEchoSub, cmdDeprecated)
+ c.AddCommand(cmdPrint, cmdEcho)
+ cmdRootWithRun.PersistentFlags().StringVarP(&flags2a, "rootflag", "r", "two", strtwoParentHelp)
+ cmdEcho.DisableAutoGenTag = true
+ out := new(bytes.Buffer)
+
+ header := &GenManHeader{
+ Title: "Project",
+ Section: "2",
+ }
+ // We generate on a subcommand so we have both subcommands and parents
+ if err := GenMan(cmdEcho, header, out); err != nil {
+ t.Fatal(err)
+ }
+ found := out.String()
+
+ unexpected := translate("#HISTORY")
+ checkStringOmits(t, found, unexpected)
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/0766779d/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_examples_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_examples_test.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_examples_test.go
new file mode 100644
index 0000000..3593853
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_examples_test.go
@@ -0,0 +1,35 @@
+package doc_test
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/spf13/cobra"
+ "github.com/spf13/cobra/doc"
+)
+
+func ExampleCommand_GenManTree() {
+ cmd := &cobra.Command{
+ Use: "test",
+ Short: "my test program",
+ }
+ header := &doc.GenManHeader{
+ Title: "MINE",
+ Section: "3",
+ }
+ doc.GenManTree(cmd, header, "/tmp")
+}
+
+func ExampleCommand_GenMan() {
+ cmd := &cobra.Command{
+ Use: "test",
+ Short: "my test program",
+ }
+ header := &doc.GenManHeader{
+ Title: "MINE",
+ Section: "3",
+ }
+ out := new(bytes.Buffer)
+ doc.GenMan(cmd, header, out)
+ fmt.Print(out.String())
+}