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:57 UTC
[32/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/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore b/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
deleted file mode 100644
index 36d1a84..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/.gitignore
+++ /dev/null
@@ -1,24 +0,0 @@
-# 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/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml b/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
deleted file mode 100644
index dc43afd..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/.travis.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-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/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt b/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
deleted file mode 100644
index 298f0e2..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/LICENSE.txt
+++ /dev/null
@@ -1,174 +0,0 @@
- 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/Godeps/_workspace/src/github.com/spf13/cobra/README.md
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/README.md b/Godeps/_workspace/src/github.com/spf13/cobra/README.md
deleted file mode 100644
index b1fb088..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/README.md
+++ /dev/null
@@ -1,485 +0,0 @@
-# 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/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go b/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
deleted file mode 100644
index 3a421bc..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.go
+++ /dev/null
@@ -1,370 +0,0 @@
-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/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md b/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
deleted file mode 100644
index 204704e..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions.md
+++ /dev/null
@@ -1,149 +0,0 @@
-# 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/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go b/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go
deleted file mode 100644
index acb6d81..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/bash_completions_test.go
+++ /dev/null
@@ -1,80 +0,0 @@
-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/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go b/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
deleted file mode 100644
index 78b92b0..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/cobra.go
+++ /dev/null
@@ -1,112 +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.
-
-// 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/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
----------------------------------------------------------------------
diff --git a/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go b/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
deleted file mode 100644
index f181a07..0000000
--- a/Godeps/_workspace/src/github.com/spf13/cobra/cobra_test.go
+++ /dev/null
@@ -1,965 +0,0 @@
-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")
- }
-}