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/17 02:09:31 UTC

[41/52] [abbrv] [partial] incubator-mynewt-newt git commit: Replace godeps _workspace with new go vendor dir.

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/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
deleted file mode 100644
index 99dafde..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
+++ /dev/null
@@ -1,1188 +0,0 @@
-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, flagi4, 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 cmdCustomFlags = &Command{
-	Use:   "customflags [flags] -- REMOTE_COMMAND",
-	Short: "A command that expects flags in a custom location",
-	Long:  "A long output about a command that expects flags in a custom location",
-	Run: func(cmd *Command, args []string) {
-	},
-}
-
-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()
-	cmdCustomFlags.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")
-	cmdCustomFlags.Flags().IntVar(&flagi4, "intfour", 456, "help message for flag intfour")
-	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()
-	cmdCustomFlags.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, cmdCustomFlags, 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 TestUsage(t *testing.T) {
-	x := fullSetupTest("help")
-	checkResultContains(t, x, cmdRootWithRun.Use + " [flags]")
-	x = fullSetupTest("help customflags")
-	checkResultContains(t, x, cmdCustomFlags.Use)
-	checkResultOmits(t, x, cmdCustomFlags.Use + " [flags]")
-}
-
-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/b002dd0c/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
deleted file mode 100644
index 7671ce5..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command.go
+++ /dev/null
@@ -1,1197 +0,0 @@
-// 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}}
-  {{if .HasFlags}}{{appendIfNotPresent .UseLine "[flags]"}}{{else}}{{.UseLine}}{{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/b002dd0c/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
deleted file mode 100644
index 073dd35..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_notwin.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// +build !windows
-
-package cobra
-
-var preExecHookFn func(*Command) = nil

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/b002dd0c/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
deleted file mode 100644
index 43ed7a3..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_test.go
+++ /dev/null
@@ -1,114 +0,0 @@
-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/b002dd0c/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
deleted file mode 100644
index 4b0eaa1..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/command_win.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// +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/b002dd0c/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
deleted file mode 100644
index a4b5568..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/cmd_test.go
+++ /dev/null
@@ -1,145 +0,0 @@
-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/b002dd0c/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
deleted file mode 100644
index f21d839..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.go
+++ /dev/null
@@ -1,218 +0,0 @@
-// 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/b002dd0c/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
deleted file mode 100644
index 5fe957a..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs.md
+++ /dev/null
@@ -1,26 +0,0 @@
-# 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/b002dd0c/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
deleted file mode 100644
index 3083125..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_docs_test.go
+++ /dev/null
@@ -1,97 +0,0 @@
-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/b002dd0c/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
deleted file mode 100644
index 3593853..0000000
--- a/newt/Godeps/_workspace/src/github.com/spf13/cobra/doc/man_examples_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-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())
-}