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 2015/11/21 01:42:36 UTC
[11/42] incubator-mynewt-newt git commit: Move newt source into a
"newt" subdirectory.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore b/newt/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
new file mode 100644
index 0000000..36d1a84
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+
+cobra.test
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml b/newt/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
new file mode 100644
index 0000000..dc43afd
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
@@ -0,0 +1,8 @@
+language: go
+go:
+ - 1.3
+ - 1.4.2
+ - tip
+script:
+ - go test ./...
+ - go build
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt b/newt/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
new file mode 100644
index 0000000..298f0e2
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
@@ -0,0 +1,174 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/README.md
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/README.md b/newt/Godeps/_workspace/src/github.com/spf13/cobra/README.md
new file mode 100644
index 0000000..b1fb088
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/README.md
@@ -0,0 +1,485 @@
+# Cobra
+
+A Commander for modern go CLI interactions
+
+[](https://travis-ci.org/spf13/cobra)
+
+## Overview
+
+Cobra is a commander providing a simple interface to create powerful modern CLI
+interfaces similar to git & go tools. In addition to providing an interface, Cobra
+simultaneously provides a controller to organize your application code.
+
+Inspired by go, go-Commander, gh and subcommand, Cobra improves on these by
+providing **fully posix compliant flags** (including short & long versions),
+**nesting commands**, and the ability to **define your own help and usage** for any or
+all commands.
+
+Cobra has an exceptionally clean interface and simple design without needless
+constructors or initialization methods.
+
+Applications built with Cobra commands are designed to be as user friendly as
+possible. Flags can be placed before or after the command (as long as a
+confusing space isn’t provided). Both short and long flags can be used. A
+command need not even be fully typed. The shortest unambiguous string will
+suffice. Help is automatically generated and available for the application or
+for a specific command using either the help command or the --help flag.
+
+## Concepts
+
+Cobra is built on a structure of commands & flags.
+
+**Commands** represent actions and **Flags** are modifiers for those actions.
+
+In the following example 'server' is a command and 'port' is a flag.
+
+ hugo server --port=1313
+
+### Commands
+
+Command is the central point of the application. Each interaction that
+the application supports will be contained in a Command. A command can
+have children commands and optionally run an action.
+
+In the example above 'server' is the command
+
+A Command has the following structure:
+
+ type Command struct {
+ Use string // The one-line usage message.
+ Short string // The short description shown in the 'help' output.
+ Long string // The long message shown in the 'help <this-command>' output.
+ Run func(cmd *Command, args []string) // Run runs the command.
+ }
+
+### Flags
+
+A Flag is a way to modify the behavior of an command. Cobra supports
+fully posix compliant flags as well as the go flag package.
+A Cobra command can define flags that persist through to children commands
+and flags that are only available to that command.
+
+In the example above 'port' is the flag.
+
+Flag functionality is provided by the [pflag
+library](https://github.com/ogier/pflag), a fork of the flag standard library
+which maintains the same interface while adding posix compliance.
+
+## Usage
+
+Cobra works by creating a set of commands and then organizing them into a tree.
+The tree defines the structure of the application.
+
+Once each command is defined with it's corresponding flags, then the
+tree is assigned to the commander which is finally executed.
+
+### Installing
+Using Cobra is easy. First use go get to install the latest version
+of the library.
+
+ $ go get github.com/spf13/cobra
+
+Next include cobra in your application.
+
+ import "github.com/spf13/cobra"
+
+### Create the root command
+
+The root command represents your binary itself.
+
+Cobra doesn't require any special constructors. Simply create your commands.
+
+ var HugoCmd = &cobra.Command{
+ Use: "hugo",
+ Short: "Hugo is a very fast static site generator",
+ Long: `A Fast and Flexible Static Site Generator built with
+ love by spf13 and friends in Go.
+ Complete documentation is available at http://hugo.spf13.com`,
+ Run: func(cmd *cobra.Command, args []string) {
+ // Do Stuff Here
+ },
+ }
+
+### Create additional commands
+
+Additional commands can be defined.
+
+ var versionCmd = &cobra.Command{
+ Use: "version",
+ Short: "Print the version number of Hugo",
+ Long: `All software has versions. This is Hugo's`,
+ Run: func(cmd *cobra.Command, args []string) {
+ fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")
+ },
+ }
+
+### Attach command to its parent
+In this example we are attaching it to the root, but commands can be attached at any level.
+
+ HugoCmd.AddCommand(versionCmd)
+
+### Assign flags to a command
+
+Since the flags are defined and used in different locations, we need to
+define a variable outside with the correct scope to assign the flag to
+work with.
+
+ var Verbose bool
+ var Source string
+
+There are two different approaches to assign a flag.
+
+#### Persistent Flags
+
+A flag can be 'persistent' meaning that this flag will be available to the
+command it's assigned to as well as every command under that command. For
+global flags assign a flag as a persistent flag on the root.
+
+ HugoCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")
+
+#### Local Flags
+
+A flag can also be assigned locally which will only apply to that specific command.
+
+ HugoCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")
+
+### Remove a command from its parent
+
+Removing a command is not a common action in simple programs but it allows 3rd parties to customize an existing command tree.
+
+In this example, we remove the existing `VersionCmd` command of an existing root command, and we replace it by our own version.
+
+ mainlib.RootCmd.RemoveCommand(mainlib.VersionCmd)
+ mainlib.RootCmd.AddCommand(versionCmd)
+
+### Once all commands and flags are defined, Execute the commands
+
+Execute should be run on the root for clarity, though it can be called on any command.
+
+ HugoCmd.Execute()
+
+## Example
+
+In the example below we have defined three commands. Two are at the top level
+and one (cmdTimes) is a child of one of the top commands. In this case the root
+is not executable meaning that a subcommand is required. This is accomplished
+by not providing a 'Run' for the 'rootCmd'.
+
+We have only defined one flag for a single command.
+
+More documentation about flags is available at https://github.com/spf13/pflag
+
+ import(
+ "github.com/spf13/cobra"
+ "fmt"
+ "strings"
+ )
+
+ func main() {
+
+ var echoTimes int
+
+ var cmdPrint = &cobra.Command{
+ Use: "print [string to print]",
+ Short: "Print anything to the screen",
+ Long: `print is for printing anything back to the screen.
+ For many years people have printed back to the screen.
+ `,
+ Run: func(cmd *cobra.Command, args []string) {
+ fmt.Println("Print: " + strings.Join(args, " "))
+ },
+ }
+
+ var cmdEcho = &cobra.Command{
+ Use: "echo [string to echo]",
+ Short: "Echo anything to the screen",
+ Long: `echo is for echoing anything back.
+ Echo works a lot like print, except it has a child command.
+ `,
+ Run: func(cmd *cobra.Command, args []string) {
+ fmt.Println("Print: " + strings.Join(args, " "))
+ },
+ }
+
+ var cmdTimes = &cobra.Command{
+ Use: "times [# times] [string to echo]",
+ Short: "Echo anything to the screen more times",
+ Long: `echo things multiple times back to the user by providing
+ a count and a string.`,
+ Run: func(cmd *cobra.Command, args []string) {
+ for i:=0; i < echoTimes; i++ {
+ fmt.Println("Echo: " + strings.Join(args, " "))
+ }
+ },
+ }
+
+ cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")
+
+ var rootCmd = &cobra.Command{Use: "app"}
+ rootCmd.AddCommand(cmdPrint, cmdEcho)
+ cmdEcho.AddCommand(cmdTimes)
+ rootCmd.Execute()
+ }
+
+For a more complete example of a larger application, please checkout [Hugo](http://hugo.spf13.com)
+
+## The Help Command
+
+Cobra automatically adds a help command to your application when you have subcommands.
+This will be called when a user runs 'app help'. Additionally help will also
+support all other commands as input. Say for instance you have a command called
+'create' without any additional configuration cobra will work when 'app help
+create' is called. Every command will automatically have the '--help' flag added.
+
+### Example
+
+The following output is automatically generated by cobra. Nothing beyond the
+command and flag definitions are needed.
+
+ > hugo help
+
+ A Fast and Flexible Static Site Generator built with
+ love by spf13 and friends in Go.
+
+ Complete documentation is available at http://hugo.spf13.com
+
+ Usage:
+ hugo [flags]
+ hugo [command]
+
+ Available Commands:
+ server :: Hugo runs it's own a webserver to render the files
+ version :: Print the version number of Hugo
+ check :: Check content in the source directory
+ benchmark :: Benchmark hugo by building a site a number of times
+ help [command] :: Help about any command
+
+ Available Flags:
+ -b, --base-url="": hostname (and path) to the root eg. http://spf13.com/
+ -D, --build-drafts=false: include content marked as draft
+ --config="": config file (default is path/config.yaml|json|toml)
+ -d, --destination="": filesystem path to write files to
+ -s, --source="": filesystem path to read files relative from
+ --stepAnalysis=false: display memory and timing of different steps of the program
+ --uglyurls=false: if true, use /filename.html instead of /filename/
+ -v, --verbose=false: verbose output
+ -w, --watch=false: watch filesystem for changes and recreate as needed
+
+ Use "hugo help [command]" for more information about that command.
+
+
+
+Help is just a command like any other. There is no special logic or behavior
+around it. In fact you can provide your own if you want.
+
+### Defining your own help
+
+You can provide your own Help command or you own template for the default command to use.
+
+The default help command is
+
+ func (c *Command) initHelp() {
+ if c.helpCommand == nil {
+ 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.`,
+ Run: c.HelpFunc(),
+ }
+ }
+ c.AddCommand(c.helpCommand)
+ }
+
+You can provide your own command, function or template through the following methods.
+
+ command.SetHelpCommand(cmd *Command)
+
+ command.SetHelpFunc(f func(*Command, []string))
+
+ command.SetHelpTemplate(s string)
+
+The latter two will also apply to any children commands.
+
+## Usage
+
+When the user provides an invalid flag or invalid command Cobra responds by
+showing the user the 'usage'
+
+### Example
+You may recognize this from the help above. That's because the default help
+embeds the usage as part of it's output.
+
+ Usage:
+ hugo [flags]
+ hugo [command]
+
+ Available Commands:
+ server Hugo runs it's own a webserver to render the files
+ version Print the version number of Hugo
+ check Check content in the source directory
+ benchmark Benchmark hugo by building a site a number of times
+ help [command] Help about any command
+
+ Available Flags:
+ -b, --base-url="": hostname (and path) to the root eg. http://spf13.com/
+ -D, --build-drafts=false: include content marked as draft
+ --config="": config file (default is path/config.yaml|json|toml)
+ -d, --destination="": filesystem path to write files to
+ -s, --source="": filesystem path to read files relative from
+ --stepAnalysis=false: display memory and timing of different steps of the program
+ --uglyurls=false: if true, use /filename.html instead of /filename/
+ -v, --verbose=false: verbose output
+ -w, --watch=false: watch filesystem for changes and recreate as needed
+
+### Defining your own usage
+You can provide your own usage function or template for cobra to use.
+
+The default usage function is
+
+ return func(c *Command) error {
+ err := tmpl(c.Out(), c.UsageTemplate(), c)
+ return err
+ }
+
+Like help the function and template are over ridable through public methods.
+
+ command.SetUsageFunc(f func(*Command) error)
+
+ command.SetUsageTemplate(s string)
+
+## PreRun or PostRun Hooks
+
+It is possible to run functions before or after the main `Run` function of your command. The `PersistentPreRun` and `PreRun` functions will be executed before `Run`. `PersistendPostRun` and `PostRun` will be executed after `Run`. The `Persistent*Run` functions will be inherrited by children if they do not declare their own. These function are run in the following order:
+
+- `PersistentPreRun`
+- `PreRun`
+- `Run`
+- `PostRun`
+- `PersistenPostRun`
+
+And example of two commands which use all of these features is below. When the subcommand in executed it will run the root command's `PersistentPreRun` but not the root command's `PersistentPostRun`
+
+```go
+package main
+
+import (
+ "fmt"
+
+ "github.com/spf13/cobra"
+)
+
+func main() {
+
+ var rootCmd = &cobra.Command{
+ Use: "root [sub]",
+ Short: "My root command",
+ PersistentPreRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside rootCmd PersistentPreRun with args: %v\n", args)
+ },
+ PreRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside rootCmd PreRun with args: %v\n", args)
+ },
+ Run: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside rootCmd Run with args: %v\n", args)
+ },
+ PostRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside rootCmd PostRun with args: %v\n", args)
+ },
+ PersistentPostRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside rootCmd PersistentPostRun with args: %v\n", args)
+ },
+ }
+
+ var subCmd = &cobra.Command{
+ Use: "sub [no options!]",
+ Short: "My sub command",
+ PreRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside subCmd PreRun with args: %v\n", args)
+ },
+ Run: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside subCmd Run with args: %v\n", args)
+ },
+ PostRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside subCmd PostRun with args: %v\n", args)
+ },
+ PersistentPostRun: func(cmd *cobra.Command, args []string) {
+ fmt.Printf("Inside subCmd PersistentPostRun with args: %v\n", args)
+ },
+ }
+
+ rootCmd.AddCommand(subCmd)
+
+ rootCmd.SetArgs([]string{""})
+ _ = rootCmd.Execute()
+ fmt.Print("\n")
+ rootCmd.SetArgs([]string{"sub", "arg1", "arg2"})
+ _ = rootCmd.Execute()
+}
+```
+
+## Generating markdown formatted documentation for your command
+
+Cobra can generate a markdown formatted document based on the subcommands, flags, etc. A simple example of how to do this for your command can be found in [Markdown Docs](md_docs.md)
+
+## Generating bash completions for your command
+
+Cobra can generate a bash completions file. If you add more information to your command these completions can be amazingly powerful and flexible. Read more about [Bash Completions](bash_completions.md)
+
+## Debugging
+
+Cobra provides a ‘DebugFlags’ method on a command which when called will print
+out everything Cobra knows about the flags for each command
+
+### Example
+
+ command.DebugFlags()
+
+## Release Notes
+* **0.9.0** June 17, 2014
+ * flags can appears anywhere in the args (provided they are unambiguous)
+ * --help prints usage screen for app or command
+ * Prefix matching for commands
+ * Cleaner looking help and usage output
+ * Extensive test suite
+* **0.8.0** Nov 5, 2013
+ * Reworked interface to remove commander completely
+ * Command now primary structure
+ * No initialization needed
+ * Usage & Help templates & functions definable at any level
+ * Updated Readme
+* **0.7.0** Sept 24, 2013
+ * Needs more eyes
+ * Test suite
+ * Support for automatic error messages
+ * Support for help command
+ * Support for printing to any io.Writer instead of os.Stderr
+ * Support for persistent flags which cascade down tree
+ * Ready for integration into Hugo
+* **0.1.0** Sept 3, 2013
+ * Implement first draft
+
+## ToDo
+* Launch proper documentation site
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Contributors
+
+Names in no particular order:
+
+* [spf13](https://github.com/spf13)
+
+## License
+
+Cobra is released under the Apache 2.0 license. See [LICENSE.txt](https://github.com/spf13/cobra/blob/master/LICENSE.txt)
+
+
+[](https://bitdeli.com/free "Bitdeli Badge")
+
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
new file mode 100644
index 0000000..3a421bc
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
@@ -0,0 +1,370 @@
+package cobra
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "sort"
+ "strings"
+
+ "github.com/spf13/pflag"
+)
+
+const (
+ BashCompFilenameExt = "cobra_annotation_bash_completion_filename_extentions"
+ BashCompOneRequiredFlag = "cobra_annotation_bash_completion_one_required_flag"
+)
+
+func preamble(out *bytes.Buffer) {
+ fmt.Fprintf(out, `#!/bin/bash
+
+
+__debug()
+{
+ if [[ -n ${BASH_COMP_DEBUG_FILE} ]]; then
+ echo "$*" >> "${BASH_COMP_DEBUG_FILE}"
+ fi
+}
+
+__index_of_word()
+{
+ local w word=$1
+ shift
+ index=0
+ for w in "$@"; do
+ [[ $w = "$word" ]] && return
+ index=$((index+1))
+ done
+ index=-1
+}
+
+__contains_word()
+{
+ local w word=$1; shift
+ for w in "$@"; do
+ [[ $w = "$word" ]] && return
+ done
+ return 1
+}
+
+__handle_reply()
+{
+ __debug "${FUNCNAME}"
+ case $cur in
+ -*)
+ compopt -o nospace
+ local allflags
+ if [ ${#must_have_one_flag[@]} -ne 0 ]; then
+ allflags=("${must_have_one_flag[@]}")
+ else
+ allflags=("${flags[*]} ${two_word_flags[*]}")
+ fi
+ COMPREPLY=( $(compgen -W "${allflags[*]}" -- "$cur") )
+ [[ $COMPREPLY == *= ]] || compopt +o nospace
+ return 0;
+ ;;
+ esac
+
+ # check if we are handling a flag with special work handling
+ local index
+ __index_of_word "${prev}" "${flags_with_completion[@]}"
+ if [[ ${index} -ge 0 ]]; then
+ ${flags_completion[${index}]}
+ return
+ fi
+
+ # we are parsing a flag and don't have a special handler, no completion
+ if [[ ${cur} != "${words[cword]}" ]]; then
+ return
+ fi
+
+ local completions
+ if [[ ${#must_have_one_flag[@]} -ne 0 ]]; then
+ completions=("${must_have_one_flag[@]}")
+ elif [[ ${#must_have_one_noun[@]} -ne 0 ]]; then
+ completions=("${must_have_one_noun[@]}")
+ else
+ completions=("${commands[@]}")
+ fi
+ COMPREPLY=( $(compgen -W "${completions[*]}" -- "$cur") )
+
+ if [[ ${#COMPREPLY[@]} -eq 0 ]]; then
+ declare -F __custom_func >/dev/null && __custom_func
+ fi
+}
+
+# The arguments should be in the form "ext1|ext2|extn"
+__handle_filename_extension_flag()
+{
+ local ext="$1"
+ _filedir "@(${ext})"
+}
+
+__handle_flag()
+{
+ __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
+
+ # if a command required a flag, and we found it, unset must_have_one_flag()
+ local flagname=${words[c]}
+ # if the word contained an =
+ if [[ ${words[c]} == *"="* ]]; then
+ flagname=${flagname%%=*} # strip everything after the =
+ flagname="${flagname}=" # but put the = back
+ fi
+ __debug "${FUNCNAME}: looking for ${flagname}"
+ if __contains_word "${flagname}" "${must_have_one_flag[@]}"; then
+ must_have_one_flag=()
+ fi
+
+ # skip the argument to a two word flag
+ if __contains_word "${words[c]}" "${two_word_flags[@]}"; then
+ c=$((c+1))
+ # if we are looking for a flags value, don't show commands
+ if [[ $c -eq $cword ]]; then
+ commands=()
+ fi
+ fi
+
+ # skip the flag itself
+ c=$((c+1))
+
+}
+
+__handle_noun()
+{
+ __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
+
+ if __contains_word "${words[c]}" "${must_have_one_noun[@]}"; then
+ must_have_one_noun=()
+ fi
+
+ nouns+=("${words[c]}")
+ c=$((c+1))
+}
+
+__handle_command()
+{
+ __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
+
+ local next_command
+ if [[ -n ${last_command} ]]; then
+ next_command="_${last_command}_${words[c]}"
+ else
+ next_command="_${words[c]}"
+ fi
+ c=$((c+1))
+ __debug "${FUNCNAME}: looking for ${next_command}"
+ declare -F $next_command >/dev/null && $next_command
+}
+
+__handle_word()
+{
+ if [[ $c -ge $cword ]]; then
+ __handle_reply
+ return
+ fi
+ __debug "${FUNCNAME}: c is $c words[c] is ${words[c]}"
+ if [[ "${words[c]}" == -* ]]; then
+ __handle_flag
+ elif __contains_word "${words[c]}" "${commands[@]}"; then
+ __handle_command
+ else
+ __handle_noun
+ fi
+ __handle_word
+}
+
+`)
+}
+
+func postscript(out *bytes.Buffer, name string) {
+ fmt.Fprintf(out, "__start_%s()\n", name)
+ fmt.Fprintf(out, `{
+ local cur prev words cword
+ _init_completion -s || return
+
+ local c=0
+ local flags=()
+ local two_word_flags=()
+ local flags_with_completion=()
+ local flags_completion=()
+ local commands=("%s")
+ local must_have_one_flag=()
+ local must_have_one_noun=()
+ local last_command
+ local nouns=()
+
+ __handle_word
+}
+
+`, name)
+ fmt.Fprintf(out, "complete -F __start_%s %s\n", name, name)
+ fmt.Fprintf(out, "# ex: ts=4 sw=4 et filetype=sh\n")
+}
+
+func writeCommands(cmd *Command, out *bytes.Buffer) {
+ fmt.Fprintf(out, " commands=()\n")
+ for _, c := range cmd.Commands() {
+ if len(c.Deprecated) > 0 {
+ continue
+ }
+ fmt.Fprintf(out, " commands+=(%q)\n", c.Name())
+ }
+ fmt.Fprintf(out, "\n")
+}
+
+func writeFlagHandler(name string, annotations map[string][]string, out *bytes.Buffer) {
+ for key, value := range annotations {
+ switch key {
+ case BashCompFilenameExt:
+ fmt.Fprintf(out, " flags_with_completion+=(%q)\n", name)
+
+ if len(value) > 0 {
+ ext := "__handle_filename_extension_flag " + strings.Join(value, "|")
+ fmt.Fprintf(out, " flags_completion+=(%q)\n", ext)
+ } else {
+ ext := "_filedir"
+ fmt.Fprintf(out, " flags_completion+=(%q)\n", ext)
+ }
+ }
+ }
+}
+
+func writeShortFlag(flag *pflag.Flag, out *bytes.Buffer) {
+ b := (flag.Value.Type() == "bool")
+ name := flag.Shorthand
+ format := " "
+ if !b {
+ format += "two_word_"
+ }
+ format += "flags+=(\"-%s\")\n"
+ fmt.Fprintf(out, format, name)
+ writeFlagHandler("-"+name, flag.Annotations, out)
+}
+
+func writeFlag(flag *pflag.Flag, out *bytes.Buffer) {
+ b := (flag.Value.Type() == "bool")
+ name := flag.Name
+ format := " flags+=(\"--%s"
+ if !b {
+ format += "="
+ }
+ format += "\")\n"
+ fmt.Fprintf(out, format, name)
+ writeFlagHandler("--"+name, flag.Annotations, out)
+}
+
+func writeFlags(cmd *Command, out *bytes.Buffer) {
+ fmt.Fprintf(out, ` flags=()
+ two_word_flags=()
+ flags_with_completion=()
+ flags_completion=()
+
+`)
+ cmd.NonInheritedFlags().VisitAll(func(flag *pflag.Flag) {
+ writeFlag(flag, out)
+ if len(flag.Shorthand) > 0 {
+ writeShortFlag(flag, out)
+ }
+ })
+
+ fmt.Fprintf(out, "\n")
+}
+
+func writeRequiredFlag(cmd *Command, out *bytes.Buffer) {
+ fmt.Fprintf(out, " must_have_one_flag=()\n")
+ flags := cmd.NonInheritedFlags()
+ flags.VisitAll(func(flag *pflag.Flag) {
+ for key, _ := range flag.Annotations {
+ switch key {
+ case BashCompOneRequiredFlag:
+ format := " must_have_one_flag+=(\"--%s"
+ b := (flag.Value.Type() == "bool")
+ if !b {
+ format += "="
+ }
+ format += "\")\n"
+ fmt.Fprintf(out, format, flag.Name)
+
+ if len(flag.Shorthand) > 0 {
+ fmt.Fprintf(out, " must_have_one_flag+=(\"-%s\")\n", flag.Shorthand)
+ }
+ }
+ }
+ })
+}
+
+func writeRequiredNoun(cmd *Command, out *bytes.Buffer) {
+ fmt.Fprintf(out, " must_have_one_noun=()\n")
+ sort.Sort(sort.StringSlice(cmd.ValidArgs))
+ for _, value := range cmd.ValidArgs {
+ fmt.Fprintf(out, " must_have_one_noun+=(%q)\n", value)
+ }
+}
+
+func gen(cmd *Command, out *bytes.Buffer) {
+ for _, c := range cmd.Commands() {
+ if len(c.Deprecated) > 0 {
+ continue
+ }
+ gen(c, out)
+ }
+ commandName := cmd.CommandPath()
+ commandName = strings.Replace(commandName, " ", "_", -1)
+ fmt.Fprintf(out, "_%s()\n{\n", commandName)
+ fmt.Fprintf(out, " last_command=%q\n", commandName)
+ writeCommands(cmd, out)
+ writeFlags(cmd, out)
+ writeRequiredFlag(cmd, out)
+ writeRequiredNoun(cmd, out)
+ fmt.Fprintf(out, "}\n\n")
+}
+
+func (cmd *Command) GenBashCompletion(out *bytes.Buffer) {
+ preamble(out)
+ if len(cmd.BashCompletionFunction) > 0 {
+ fmt.Fprintf(out, "%s\n", cmd.BashCompletionFunction)
+ }
+ gen(cmd, out)
+ postscript(out, cmd.Name())
+}
+
+func (cmd *Command) GenBashCompletionFile(filename string) error {
+ out := new(bytes.Buffer)
+
+ cmd.GenBashCompletion(out)
+
+ outFile, err := os.Create(filename)
+ if err != nil {
+ return err
+ }
+ defer outFile.Close()
+
+ _, err = outFile.Write(out.Bytes())
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag, if it exists.
+func (cmd *Command) MarkFlagRequired(name string) error {
+ return MarkFlagRequired(cmd.Flags(), name)
+}
+
+// MarkFlagRequired adds the BashCompOneRequiredFlag annotation to the named flag in the flag set, if it exists.
+func MarkFlagRequired(flags *pflag.FlagSet, name string) error {
+ return flags.SetAnnotation(name, BashCompOneRequiredFlag, []string{"true"})
+}
+
+// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag, if it exists.
+// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
+func (cmd *Command) MarkFlagFilename(name string, extensions ...string) error {
+ return MarkFlagFilename(cmd.Flags(), name, extensions...)
+}
+
+// MarkFlagFilename adds the BashCompFilenameExt annotation to the named flag in the flag set, if it exists.
+// Generated bash autocompletion will select filenames for the flag, limiting to named extensions if provided.
+func MarkFlagFilename(flags *pflag.FlagSet, name string, extensions ...string) error {
+ return flags.SetAnnotation(name, BashCompFilenameExt, extensions)
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md b/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
new file mode 100644
index 0000000..204704e
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
@@ -0,0 +1,149 @@
+# Generating Bash Completions For Your Own cobra.Command
+
+Generating bash completions from a cobra command is incredibly easy. An actual program which does so for the kubernetes kubectl binary is as follows:
+
+```go
+package main
+
+import (
+ "io/ioutil"
+ "os"
+
+ "github.com/GoogleCloudPlatform/kubernetes/pkg/kubectl/cmd"
+)
+
+func main() {
+ kubectl := cmd.NewFactory(nil).NewKubectlCommand(os.Stdin, ioutil.Discard, ioutil.Discard)
+ kubectl.GenBashCompletionFile("out.sh")
+}
+```
+
+That will get you completions of subcommands and flags. If you make additional annotations to your code, you can get even more intelligent and flexible behavior.
+
+## Creating your own custom functions
+
+Some more actual code that works in kubernetes:
+
+```bash
+const (
+ bash_completion_func = `__kubectl_parse_get()
+{
+ local kubectl_output out
+ if kubectl_output=$(kubectl get --no-headers "$1" 2>/dev/null); then
+ out=($(echo "${kubectl_output}" | awk '{print $1}'))
+ COMPREPLY=( $( compgen -W "${out[*]}" -- "$cur" ) )
+ fi
+}
+
+__kubectl_get_resource()
+{
+ if [[ ${#nouns[@]} -eq 0 ]]; then
+ return 1
+ fi
+ __kubectl_parse_get ${nouns[${#nouns[@]} -1]}
+ if [[ $? -eq 0 ]]; then
+ return 0
+ fi
+}
+
+__custom_func() {
+ case ${last_command} in
+ kubectl_get | kubectl_describe | kubectl_delete | kubectl_stop)
+ __kubectl_get_resource
+ return
+ ;;
+ *)
+ ;;
+ esac
+}
+`)
+```
+
+And then I set that in my command definition:
+
+```go
+cmds := &cobra.Command{
+ Use: "kubectl",
+ Short: "kubectl controls the Kubernetes cluster manager",
+ Long: `kubectl controls the Kubernetes cluster manager.
+
+Find more information at https://github.com/GoogleCloudPlatform/kubernetes.`,
+ Run: runHelp,
+ BashCompletionFunction: bash_completion_func,
+}
+```
+
+The `BashCompletionFunction` option is really only valid/useful on the root command. Doing the above will cause `__custom_func()` to be called when the built in processor was unable to find a solution. In the case of kubernetes a valid command might look something like `kubectl get pod [mypod]`. If you type `kubectl get pod [tab][tab]` the `__customc_func()` will run because the cobra.Command only understood "kubectl" and "get." `__custom_func()` will see that the cobra.Command is "kubectl_get" and will thus call another helper `__kubectl_get_resource()`. `__kubectl_get_resource` will look at the 'nouns' collected. In our example the only noun will be `pod`. So it will call `__kubectl_parse_get pod`. `__kubectl_parse_get` will actually call out to kubernetes and get any pods. It will then set `COMPREPLY` to valid pods!
+
+## Have the completions code complete your 'nouns'
+
+In the above example "pod" was assumed to already be typed. But if you want `kubectl get [tab][tab]` to show a list of valid "nouns" you have to set them. Simplified code from `kubectl get` looks like:
+
+```go
+validArgs []string = { "pods", "nodes", "services", "replicationControllers" }
+
+cmd := &cobra.Command{
+ Use: "get [(-o|--output=)json|yaml|template|...] (RESOURCE [NAME] | RESOURCE/NAME ...)",
+ Short: "Display one or many resources",
+ Long: get_long,
+ Example: get_example,
+ Run: func(cmd *cobra.Command, args []string) {
+ err := RunGet(f, out, cmd, args)
+ util.CheckErr(err)
+ },
+ ValidArgs: validArgs,
+}
+```
+
+Notice we put the "ValidArgs" on the "get" subcommand. Doing so will give results like
+
+```bash
+# kubectl get [tab][tab]
+nodes pods replicationControllers services
+```
+
+## Mark flags as required
+
+Most of the time completions will only show subcommands. But if a flag is required to make a subcommand work, you probably want it to show up when the user types [tab][tab]. Marking a flag as 'Required' is incredibly easy.
+
+```go
+cmd.MarkFlagRequired("pod")
+cmd.MarkFlagRequired("container")
+```
+
+and you'll get something like
+
+```bash
+# kubectl exec [tab][tab][tab]
+-c --container= -p --pod=
+```
+
+# Specify valid filename extensions for flags that take a filename
+
+In this example we use --filename= and expect to get a json or yaml file as the argument. To make this easier we annotate the --filename flag with valid filename extensions.
+
+```go
+ annotations := []string{"json", "yaml", "yml"}
+ annotation := make(map[string][]string)
+ annotation[cobra.BashCompFilenameExt] = annotations
+
+ flag := &pflag.Flag{
+ Name: "filename",
+ Shorthand: "f",
+ Usage: usage,
+ Value: value,
+ DefValue: value.String(),
+ Annotations: annotation,
+ }
+ cmd.Flags().AddFlag(flag)
+```
+
+Now when you run a command with this filename flag you'll get something like
+
+```bash
+# kubectl create -f
+test/ example/ rpmbuild/
+hello.yml test.json
+```
+
+So while there are many other files in the CWD it only shows me subdirs and those with valid extensions.
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go
new file mode 100644
index 0000000..acb6d81
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go
@@ -0,0 +1,80 @@
+package cobra
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "strings"
+ "testing"
+)
+
+var _ = fmt.Println
+var _ = os.Stderr
+
+func checkOmit(t *testing.T, found, unexpected string) {
+ if strings.Contains(found, unexpected) {
+ t.Errorf("Unexpected response.\nGot: %q\nBut should not have!\n", unexpected)
+ }
+}
+
+func check(t *testing.T, found, expected string) {
+ if !strings.Contains(found, expected) {
+ t.Errorf("Unexpected response.\nExpecting to contain: \n %q\nGot:\n %q\n", expected, found)
+ }
+}
+
+// World worst custom function, just keep telling you to enter hello!
+const (
+ bash_completion_func = `__custom_func() {
+COMPREPLY=( "hello" )
+}
+`
+)
+
+func TestBashCompletions(t *testing.T) {
+ c := initializeWithRootCmd()
+ cmdEcho.AddCommand(cmdTimes)
+ c.AddCommand(cmdEcho, cmdPrint, cmdDeprecated)
+
+ // custom completion function
+ c.BashCompletionFunction = bash_completion_func
+
+ // required flag
+ c.MarkFlagRequired("introot")
+
+ // valid nouns
+ validArgs := []string{"pods", "nodes", "services", "replicationControllers"}
+ c.ValidArgs = validArgs
+
+ // filename
+ var flagval string
+ c.Flags().StringVar(&flagval, "filename", "", "Enter a filename")
+ c.MarkFlagFilename("filename", "json", "yaml", "yml")
+
+ // filename extensions
+ var flagvalExt string
+ c.Flags().StringVar(&flagvalExt, "filename-ext", "", "Enter a filename (extension limited)")
+ c.MarkFlagFilename("filename-ext")
+
+ out := new(bytes.Buffer)
+ c.GenBashCompletion(out)
+ str := out.String()
+
+ check(t, str, "_cobra-test")
+ check(t, str, "_cobra-test_echo")
+ check(t, str, "_cobra-test_echo_times")
+ check(t, str, "_cobra-test_print")
+
+ // check for required flags
+ check(t, str, `must_have_one_flag+=("--introot=")`)
+ // check for custom completion function
+ check(t, str, `COMPREPLY=( "hello" )`)
+ // check for required nouns
+ check(t, str, `must_have_one_noun+=("pods")`)
+ // check for filename extension flags
+ check(t, str, `flags_completion+=("_filedir")`)
+ // check for filename extension flags
+ check(t, str, `flags_completion+=("__handle_filename_extension_flag json|yaml|yml")`)
+
+ checkOmit(t, str, cmdDeprecated.Name())
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
----------------------------------------------------------------------
diff --git a/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go b/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
new file mode 100644
index 0000000..78b92b0
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
@@ -0,0 +1,112 @@
+// 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.
+
+// Commands similar to git, go tools and other modern CLI tools
+// inspired by go, go-Commander, gh and subcommand
+
+package cobra
+
+import (
+ "fmt"
+ "io"
+ "reflect"
+ "strconv"
+ "strings"
+ "text/template"
+)
+
+var initializers []func()
+
+// automatic prefix matching can be a dangerous thing to automatically enable in CLI tools.
+// Set this to true to enable it
+var EnablePrefixMatching bool = false
+
+// enables an information splash screen on Windows if the CLI is started from explorer.exe.
+var EnableWindowsMouseTrap bool = true
+
+var MousetrapHelpText string = `This is a command line tool
+
+You need to open cmd.exe and run it from there.
+`
+
+//OnInitialize takes a series of func() arguments and appends them to a slice of func().
+func OnInitialize(y ...func()) {
+ for _, x := range y {
+ initializers = append(initializers, x)
+ }
+}
+
+//Gt takes two types and checks whether the first type is greater than the second. In case of types Arrays, Chans,
+//Maps and Slices, Gt will compare their lengths. Ints are compared directly while strings are first parsed as
+//ints and then compared.
+func Gt(a interface{}, b interface{}) bool {
+ var left, right int64
+ av := reflect.ValueOf(a)
+
+ switch av.Kind() {
+ case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
+ left = int64(av.Len())
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ left = av.Int()
+ case reflect.String:
+ left, _ = strconv.ParseInt(av.String(), 10, 64)
+ }
+
+ bv := reflect.ValueOf(b)
+
+ switch bv.Kind() {
+ case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
+ right = int64(bv.Len())
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ right = bv.Int()
+ case reflect.String:
+ right, _ = strconv.ParseInt(bv.String(), 10, 64)
+ }
+
+ return left > right
+}
+
+//Eq takes two types and checks whether they are equal. Supported types are int and string. Unsupported types will panic.
+func Eq(a interface{}, b interface{}) bool {
+ av := reflect.ValueOf(a)
+ bv := reflect.ValueOf(b)
+
+ switch av.Kind() {
+ case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
+ panic("Eq called on unsupported type")
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return av.Int() == bv.Int()
+ case reflect.String:
+ return av.String() == bv.String()
+ }
+ return false
+}
+
+//rpad adds padding to the right of a string
+func rpad(s string, padding int) string {
+ template := fmt.Sprintf("%%-%ds", padding)
+ return fmt.Sprintf(template, s)
+}
+
+// tmpl executes the given template text on data, writing the result to w.
+func tmpl(w io.Writer, text string, data interface{}) error {
+ t := template.New("top")
+ t.Funcs(template.FuncMap{
+ "trim": strings.TrimSpace,
+ "rpad": rpad,
+ "gt": Gt,
+ "eq": Eq,
+ })
+ template.Must(t.Parse(text))
+ return t.Execute(w, data)
+}
http://git-wip-us.apache.org/repos/asf/incubator-mynewt-newt/blob/e95057f4/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..f181a07
--- /dev/null
+++ b/newt/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
@@ -0,0 +1,965 @@
+package cobra
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "reflect"
+ "runtime"
+ "strings"
+ "testing"
+
+ "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 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 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]",
+ 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 it's 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 it's 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
+ },
+}
+
+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 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 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 checkResultContains(t *testing.T, x resulter, check string) {
+ if !strings.Contains(x.Output, check) {
+ logErr(t, x.Output, check)
+ }
+}
+
+func checkResultOmits(t *testing.T, x resulter, check string) {
+ if strings.Contains(x.Output, check) {
+ logErr(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 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 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.Output, "unknown shorthand") {
+ t.Errorf("Wrong error message displayed, \n %s", r.Output)
+ }
+
+ 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.Output, "unknown shorthand flag") {
+ t.Errorf("Wrong error message displayed, \n %s", r.Output)
+ }
+
+ // 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.Output, "invalid argument \"10E\" for i10E") {
+ t.Errorf("Wrong error message displayed, \n %s", r.Output)
+ }
+}
+
+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")
+
+ checkResultContains(t, result, "unknown flag: --badflag")
+
+ if strings.Contains(result.Output, "unknown flag: --inttwo") {
+ t.Errorf("invalid --badflag flag shouldn't fail on 'unknown' --inttwo flag")
+ }
+
+}
+
+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 it's 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 it's 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) {
+ fullSetupTest("")
+
+ if rootcalled != true {
+ t.Errorf("Root Function was not called")
+ }
+}
+
+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)
+
+ c.Execute()
+
+ 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\"\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 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.Output, "invalid argument \"10E\" for i10E") {
+ t.Errorf("Wrong error message displayed, \n %s", x.Output)
+ }
+
+ //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")
+ }
+}