pax_global_header00006660000000000000000000000064134651120050014507gustar00rootroot0000000000000052 comment=9b8ce431ec028691b79d71211c3848f1ad4078d7 mow.cli-1.1.0/000077500000000000000000000000001346511200500130565ustar00rootroot00000000000000mow.cli-1.1.0/.gitignore000066400000000000000000000001321346511200500150420ustar00rootroot00000000000000testdata/*.golden coverage.out *.coverprofile README.generated.md README.original.md bin/ mow.cli-1.1.0/.golangci.yml000066400000000000000000000001331346511200500154370ustar00rootroot00000000000000run: skip-files: - "examples_.*.go" linters: enable: - goimports - golint mow.cli-1.1.0/.travis.yml000066400000000000000000000006301346511200500151660ustar00rootroot00000000000000language: go go: - "1.12" - "1.11" sudo: false env: - GO111MODULE=on install: make setup script: make check test-cover deploy: provider: releases api_key: secure: D2fwuS7n54ZkjfRmLMEAnwR2lQLa5xd+4s0l65pI6UN4ljVfQwQiFdZXaZWFr8PYSTKTm0UPj6Iqqw7VOl8I6iDzcaOqN3hoh5mDaJ7kyo7GZRPodwK9MKdOp5dPw459L2Atll8kxb4iYmfnjmcl0lDCUuWvMxXx+zgiFTB7BO0= skip_cleanup: true on: tags: true go: "1.12" mow.cli-1.1.0/LICENSE000066400000000000000000000021231346511200500140610ustar00rootroot00000000000000 The MIT License Copyright (c) 2014, Jawher Moussa Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. mow.cli-1.1.0/Makefile000066400000000000000000000013771346511200500145260ustar00rootroot00000000000000test: go test ./... test-cover: go list -f '{{if len .TestGoFiles}}"go test -coverprofile={{.Dir}}/.coverprofile {{.ImportPath}}"{{end}}' ./... | xargs -L 1 sh -c gover goveralls -coverprofile=gover.coverprofile -service=travis-ci check: readmecheck bin/golangci-lint run doc: autoreadme -f readmecheck: sed '$ d' README.md > README.original.md autoreadme -f sed '$ d' README.md > README.generated.md diff README.generated.md README.original.md setup: go get golang.org/x/tools/cmd/cover go get github.com/mattn/goveralls go get github.com/modocache/gover go get github.com/divan/autoreadme curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s v1.16.0 .PHONY: test check lint vet fmtcheck ineffassign readmecheck mow.cli-1.1.0/README.md000066400000000000000000001103701346511200500143370ustar00rootroot00000000000000# mow.cli [![Build Status](https://travis-ci.org/jawher/mow.cli.svg?branch=master)](https://travis-ci.org/jawher/mow.cli) [![GoDoc](https://godoc.org/github.com/github.com/jawher/mow.cli?status.svg)](https://godoc.org/github.com/jawher/mow.cli) [![Coverage Status](https://coveralls.io/repos/github/jawher/mow.cli/badge.svg?branch=master)](https://coveralls.io/github/jawher/mow.cli?branch=master) Package cli provides a framework to build command line applications in Go with most of the burden of arguments parsing and validation placed on the framework instead of the user. ## Getting Started The following examples demonstrate basic usage the package. ### Simple Application In this simple application, we mimic the argument parsing of the standard UNIX cp command. Our application requires the user to specify one or more source files followed by a destination. An optional recursive flag may be provided. ```go package main import ( "fmt" "os" "github.com/jawher/mow.cli" ) func main() { // create an app app := cli.App("cp", "Copy files around") // Here's what differentiates mow.cli from other CLI libraries: // This line is not just for help message generation. // It also validates the call to reject calls with less than 2 arguments // and split the arguments between SRC or DST app.Spec = "[-r] SRC... DST" var ( // declare the -r flag as a boolean flag recursive = app.BoolOpt("r recursive", false, "Copy files recursively") // declare the SRC argument as a multi-string argument src = app.StringsArg("SRC", nil, "Source files to copy") // declare the DST argument as a single string (string slice) arguments dst = app.StringArg("DST", "", "Destination where to copy files to") ) // Specify the action to execute when the app is invoked correctly app.Action = func() { fmt.Printf("Copying %v to %s [recursively: %v]\n", *src, *dst, *recursive) } // Invoke the app passing in os.Args app.Run(os.Args) } ``` ### Pointers to existing variables This variant of the cp command uses the Ptr variants, where you can pass pointers to existing variables instead of declaring new ones for the options/arguments: ```go package main import ( "fmt" "os" cli "github.com/jawher/mow.cli" ) type Config struct { Recursive bool Src []string Dst string } func main() { var ( app = cli.App("cp", "Copy files around") cfg Config ) // Here's what differentiates mow.cli from other CLI libraries: // This line is not just for help message generation. // It also validates the call to reject calls with less than 2 arguments // and split the arguments between SRC or DST app.Spec = "[-r] SRC... DST" // declare the -r flag as a boolean flag app.BoolOptPtr(&cfg.Recursive, "r recursive", false, "Copy files recursively") // declare the SRC argument as a multi-string argument app.StringsArgPtr(&cfg.Src, "SRC", nil, "Source files to copy") // declare the DST argument as a single string (string slice) arguments app.StringArgPtr(&cfg.Dst, "DST", "", "Destination where to copy files to") // Specify the action to execute when the app is invoked correctly app.Action = func() { fmt.Printf("Copying using config: %+v\n", cfg) } // Invoke the app passing in os.Args app.Run(os.Args) } ``` ### Multi-Command Application In the next example, we create a multi-command application in the same style as familiar commands such as git and docker. We build a fictional utility called uman to manage users in a system. It provides two commands that can be invoked: list and get. The list command takes an optional flag to specify all users including disabled ones. The get command requries one argument, the user ID, and takes an optional flag to specify a detailed listing. ```go package main import ( "fmt" "os" "github.com/jawher/mow.cli" ) func main() { app := cli.App("uman", "User Manager") app.Spec = "[-v]" var ( verbose = app.BoolOpt("v verbose", false, "Verbose debug mode") ) app.Before = func() { if *verbose { // Here we can enable debug output in our logger for example fmt.Println("Verbose mode enabled") } } // Declare our first command, which is invocable with "uman list" app.Command("list", "list the users", func(cmd *cli.Cmd) { // These are the command-specific options and args, nicely scoped // inside a func so they don't pollute the namespace var ( all = cmd.BoolOpt("all", false, "List all users, including disabled") ) // Run this function when the command is invoked cmd.Action = func() { // Inside the action, and only inside, we can safely access the // values of the options and arguments fmt.Printf("user list (including disabled ones: %v)\n", *all) } }) // Declare our second command, which is invocable with "uman get" app.Command("get", "get a user details", func(cmd *cli.Cmd) { var ( detailed = cmd.BoolOpt("detailed", false, "Disaply detailed info") id = cmd.StringArg("ID", "", "The user id to display") ) cmd.Action = func() { fmt.Printf("user %q details (detailed mode: %v)\n", *id, *detailed) } }) // With the app configured, execute it, passing in the os.Args array app.Run(os.Args) } ``` ### A Larger Multi-Command Example This example shows an alternate way of organizing our code when dealing with a larger number of commands and subcommands. This layout emphasizes the command structure and defers the details of each command to subsequent functions. Like the prior examples, options and arguments are still scoped to their respective functions and don't pollute the global namespace. ```go package main import ( "fmt" "os" "github.com/jawher/mow.cli" ) // Global options available to any of the commands var filename *string func main() { app := cli.App("vault", "Password Keeper") // Define our top-level global options filename = app.StringOpt("f file", os.Getenv("HOME")+"/.safe", "Path to safe") // Define our command structure for usage like this: app.Command("list", "list accounts", cmdList) app.Command("creds", "display account credentials", cmdCreds) app.Command("config", "manage accounts", func(config *cli.Cmd) { config.Command("list", "list accounts", cmdList) config.Command("add", "add an account", cmdAdd) config.Command("remove", "remove an account(s)", cmdRemove) }) app.Run(os.Args) } // Sample use: vault list OR vault config list func cmdList(cmd *cli.Cmd) { cmd.Action = func() { fmt.Printf("list the contents of the safe here") } } // Sample use: vault creds reddit.com func cmdCreds(cmd *cli.Cmd) { cmd.Spec = "ACCOUNT" account := cmd.StringArg("ACCOUNT", "", "Name of account") cmd.Action = func() { fmt.Printf("display account info for %s\n", *account) } } // Sample use: vault config add reddit.com -u username -p password func cmdAdd(cmd *cli.Cmd) { cmd.Spec = "ACCOUNT [ -u= ] [ -p= ]" var ( account = cmd.StringArg("ACCOUNT", "", "Account name") username = cmd.StringOpt("u username", "admin", "Account username") password = cmd.StringOpt("p password", "admin", "Account password") ) cmd.Action = func() { fmt.Printf("Adding account %s:%s@%s", *username, *password, *account) } } // Sample use: vault config remove reddit.com twitter.com func cmdRemove(cmd *cli.Cmd) { cmd.Spec = "ACCOUNT..." var ( accounts = cmd.StringsArg("ACCOUNT", nil, "Account names to remove") ) cmd.Action = func() { fmt.Printf("Deleting accounts: %v", *accounts) } } ``` ## Comparison to Other Tools There are several tools in the Go ecosystem to facilitate the creation of command line tools. The following is a comparison to the built-in flag package as well as the popular urfave/cli (formerly known as codegangsta/cli): | | mow.cli | urfave/cli | flag | |---------------------------------------------------------------------|---------|------------|------| | Contextual help | ✓ | ✓ | | | Commands | ✓ | ✓ | | | Option folding `-xyz` | ✓ | | | | Option value folding `-fValue` | ✓ | | | | Option exclusion `--start ❘ --stop` | ✓ | | | | Option dependency `[-a -b]` or `[-a [-b]]` | ✓ | | | | Arguments validation `SRC DST` | ✓ | | | | Argument optionality `SRC [DST]` | ✓ | | | | Argument repetition `SRC... DST` | ✓ | | | | Option/argument dependency `SRC [-f DST]` | ✓ | | | | Any combination of the above `[-d ❘ --rm] IMAGE [COMMAND [ARG...]]` | ✓ | | | Unlike the simple packages above, docopt is another library that supports rich set of flag and argument validation. It does, however, fall short for many use cases including: | | mow.cli | docopt | |----------------------------|---------|--------| | Contextual help | ✓ | | | Backtracking `SRC... DST` | ✓ | | | Backtracking `[SRC] DST` | ✓ | | | Branching `(SRC ❘ -f DST)` | ✓ | | ## Installation To install this package, run the following: ```shell go get github.com/jawher/mow.cli ``` # Package Documentation Package cli provides a framework to build command line applications in Go with most of the burden of arguments parsing and validation placed on the framework instead of the user. ## Basics To create a new application, initialize an app with cli.App. Specify a name and a brief description for the application: ``` cp := cli.App("cp", "Copy files around") ``` To attach code to execute when the app is launched, assign a function to the Action field: ``` cp.Action = func() { fmt.Printf("Hello world\n") } ``` To assign a version to the application, use Version method and specify the flags that will be used to invoke the version command: ``` cp.Version("v version", "cp 1.2.3") ``` Finally, in the main func, call Run passing in the arguments for parsing: ``` cp.Run(os.Args) ``` ## Options To add one or more command line options (also known as flags), use one of the short-form StringOpt, StringsOpt, IntOpt, IntsOpt, Float64Opt, Floats64Opt, or BoolOpt methods on App (or Cmd if adding flags to a command or a subcommand). For example, to add a boolean flag to the cp command that specifies recursive mode, use the following: ``` recursive := cp.BoolOpt("R recursive", false, "recursively copy the src to dst") ``` or: ``` cp.BoolOptPtr(&cfg.recursive, "R recursive", false, "recursively copy the src to dst") ``` The first version returns a new pointer to a bool value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. The option name(s) is a space separated list of names (without the dashes). The one letter names can then be called with a single dash (short option, -R), the others with two dashes (long options, --recursive). You also specify the default value for the option if it is not supplied by the user. The last parameter is the description to be shown in help messages. There is also a second set of methods on App called String, Strings, Int, Ints, and Bool, which accept a long-form struct of the type: cli.StringOpt, cli.StringsOpt, cli.IntOpt, cli.IntsOpt, cli.Float64Opt, cli.Floats64Opt, cli.BoolOpt. The struct describes the option and allows the use of additional features not available in the short-form methods described above: ``` recursive = cp.Bool(cli.BoolOpt{ Name: "R recursive", Value: false, Desc: "copy src files recursively", EnvVar: "VAR_RECURSIVE", SetByUser: &recursiveSetByUser, }) ``` Or: ``` recursive = cp.BoolPtr(&recursive, cli.BoolOpt{ Name: "R recursive", Value: false, Desc: "copy src files recursively", EnvVar: "VAR_RECURSIVE", SetByUser: &recursiveSetByUser, }) ``` The first version returns a new pointer to a value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. Two features, EnvVar and SetByUser, can be defined in the long-form struct method. EnvVar is a space separated list of environment variables used to initialize the option if a value is not provided by the user. When help messages are shown, the value of any environment variables will be displayed. SetByUser is a pointer to a boolean variable that is set to true if the user specified the value on the command line. This can be useful to determine if the value of the option was explicitly set by the user or set via the default value. You can only access the values stored in the pointers in the Action func, which is invoked after argument parsing has been completed. This precludes using the value of one option as the default value of another. On the command line, the following syntaxes are supported when specifying options. Boolean options: ``` -f single dash one letter name -f=false single dash one letter name, equal sign followed by true or false --force double dash for longer option names -it single dash for multiple one letter names (option folding), this is equivalent to: -i -t ``` String, int and float options: ``` -e=value single dash one letter name, equal sign, followed by the value -e value single dash one letter name, space followed by the value -Ivalue single dash one letter name, immediately followed by the value --extra=value double dash for longer option names, equal sign followed by the value --extra value double dash for longer option names, space followed by the value ``` Slice options (StringsOpt, IntsOpt, Floats64Opt) where option is repeated to accumulate values in a slice: ``` -e PATH:/bin -e PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] -ePATH:/bin -ePATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] -e=PATH:/bin -e=PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] --env PATH:/bin --env PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] --env=PATH:/bin --env=PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] ``` ## Arguments To add one or more command line arguments (not prefixed by dashes), use one of the short-form StringArg, StringsArg, IntArg, IntsArg, Float64Arg, Floats64Arg, or BoolArg methods on App (or Cmd if adding arguments to a command or subcommand). For example, to add two string arguments to our cp command, use the following calls: ``` src := cp.StringArg("SRC", "", "the file to copy") dst := cp.StringArg("DST", "", "the destination") ``` Or: ``` cp.StringArgPtr(&src, "SRC", "", "the file to copy") cp.StringArgPtr(&dst, "DST", "", "the destination") ``` The first version returns a new pointer to a value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. You then specify the argument as will be displayed in help messages. Argument names must be specified as all uppercase. The next parameter is the default value for the argument if it is not supplied. And the last is the description to be shown in help messages. There is also a second set of methods on App called String, Strings, Int, Ints, Float64, Floats64 and Bool, which accept a long-form struct of the type: cli.StringArg, cli.StringsArg, cli.IntArg, cli.IntsArg, cli.BoolArg. The struct describes the arguments and allows the use of additional features not available in the short-form methods described above: ``` src = cp.Strings(StringsArg{ Name: "SRC", Desc: "The source files to copy", Value: "default value", EnvVar: "VAR1 VAR2", SetByUser: &srcSetByUser, }) ``` Or: ``` src = cp.StringsPtr(&src, StringsArg{ Name: "SRC", Desc: "The source files to copy", Value: "default value", EnvVar: "VAR1 VAR2", SetByUser: &srcSetByUser, }) ``` The first version returns a new pointer to a value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. Two features, EnvVar and SetByUser, can be defined in the long-form struct method. EnvVar is a space separated list of environment variables used to initialize the argument if a value is not provided by the user. When help messages are shown, the value of any environment variables will be displayed. SetByUser is a pointer to a boolean variable that is set to true if the user specified the value on the command line. This can be useful to determine if the value of the argument was explicitly set by the user or set via the default value. You can only access the values stored in the pointers in the Action func, which is invoked after argument parsing has been completed. This precludes using the value of one argument as the default value of another. ## Operators The -- operator marks the end of command line options. Everything that follows will be treated as an argument, even if starts with a dash. For example, the standard POSIX touch command, which takes a filename as an argument (and possibly other options that we'll ignore here), could be defined as: ``` file := cp.StringArg("FILE", "", "the file to create") ``` If we try to create a file named "-f" via our touch command: ``` $ touch -f ``` It will fail because the -f will be parsed as an option, not as an argument. The fix is to insert -- after all flags have been specified, so the remaining arguments are parsed as arguments instead of options as follows: ``` $ touch -- -f ``` This ensures the -f is parsed as an argument instead of a flag named f. ## Commands This package supports nesting of commands and subcommands. Declare a top-level command by calling the Command func on the top-level App struct. For example, the following creates an application called docker that will have one command called run: ``` docker := cli.App("docker", "A self-sufficient runtime for linux containers") docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { // initialize the run command here }) ``` The first argument is the name of the command the user will specify on the command line to invoke this command. The second argument is the description of the command shown in help messages. And, the last argument is a CmdInitializer, which is a function that receives a pointer to a Cmd struct representing the command. Within this function, define the options and arguments for the command by calling the same methods as you would with top-level App struct (BoolOpt, StringArg, ...). To execute code when the command is invoked, assign a function to the Action field of the Cmd struct. Within that function, you can safely refer to the options and arguments as command line parsing will be completed at the time the function is invoked: ``` docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { var ( detached = cmd.BoolOpt("d detach", false, "Run container in background") memory = cmd.StringOpt("m memory", "", "Set memory limit") image = cmd.StringArg("IMAGE", "", "The image to run") ) cmd.Action = func() { if *detached { // do something } runContainer(*image, *detached, *memory) } }) ``` Optionally, to provide a more extensive description of the command, assign a string to LongDesc, which is displayed when a user invokes --help. A LongDesc can be provided for Cmds as well as the top-level App: ``` cmd.LongDesc = `Run a command in a new container With the docker run command, an operator can add to or override the image defaults set by a developer. And, additionally, operators can override nearly all the defaults set by the Docker runtime itself. The operator’s ability to override image and Docker runtime defaults is why run has more options than any other docker command.` ``` Subcommands can be added by calling Command on the Cmd struct. They can by defined to any depth if needed: ``` docker.Command("job", "actions on jobs", func(job *cli.Cmd) { job.Command("list", "list jobs", listJobs) job.Command("start", "start a new job", startJob) job.Command("log", "log commands", func(log *cli.Cmd) { log.Command("show", "show logs", showLog) log.Command("clear", "clear logs", clearLog) }) }) ``` Command and subcommand aliases are also supported. To define one or more aliases, specify a space-separated list of strings to the first argument of Command: ``` job.Command("start run r", "start a new job", startJob) ``` With the command structure defined above, users can invoke the app in a variety of ways: ``` $ docker job list $ docker job start $ docker job run # using the alias we defined $ docker job r # using the alias we defined $ docker job log show $ docker job log clear ``` As a convenience, to assign an Action to a func with no arguments, use ActionCommand when defining the Command. For example, the following two statements are equivalent: ``` app.Command("list", "list all configs", cli.ActionCommand(list)) // Exactly the same as above, just more verbose app.Command("list", "list all configs", func(cmd *cli.Cmd)) { cmd.Action = func() { list() } } ``` Please note that options, arguments, specs, and long descriptions cannot be provided when using ActionCommand. This is intended for very simple command invocations that take no arguments. Finally, as a side-note, it may seem a bit weird that this package uses a function to initialize a command instead of simply returning a command struct. The motivation behind this API decision is scoping: as with the standard flag package, adding an option or an argument returns a pointer to a value which will be populated when the app is run. Since you'll want to store these pointers in variables, and to avoid having dozens of them in the same scope (the main func for example or as global variables), this API was specifically tailored to take a func parameter (called CmdInitializer), which accepts the command struct. With this design, the command's specific variables are limited in scope to this function. ## Interceptors Interceptors, or hooks, can be defined to be executed before and after a command or when any of its subcommands are executed. For example, the following app defines multiple commands as well as a global flag which toggles verbosity: ``` app := cli.App("app", "bla bla") verbose := app.BoolOpt("verbose v", false, "Enable debug logs") app.Command("command1", "...", func(cmd *cli.Cmd) { if (*verbose) { logrus.SetLevel(logrus.DebugLevel) } }) app.Command("command2", "...", func(cmd *cli.Cmd) { if (*verbose) { logrus.SetLevel(logrus.DebugLevel) } }) ``` Instead of duplicating the check for the verbose flag and setting the debug level in every command (and its sub-commands), a Before interceptor can be set on the top-level App instead: ``` app.Before = func() { if (*verbose) { logrus.SetLevel(logrus.DebugLevel) } } ``` Whenever a valid command is called by the user, all the Before interceptors defined on the app and the intermediate commands will be called, in order from the root to the leaf. Similarly, to execute a hook after a command has been called, e.g. to cleanup resources allocated in Before interceptors, simply set the After field of the App struct or any other Command. After interceptors will be called, in order, from the leaf up to the root (the opposite order of the Before interceptors). The following diagram shows when and in which order multiple Before and After interceptors are executed: ``` +------------+ success +------------+ success +----------------+ success | app.Before +---------------> cmd.Before +-------------> sub_cmd.Before +---------+ +------------+ +-+----------+ +--+-------------+ | | | +-v-------+ error | error | | sub_cmd | +-----------------------+ +-----------------------+ | Action | | | +-+-------+ +------v-----+ +-----v------+ +----------------+ | | app.After <---------------+ cmd.After <-------------+ sub_cmd.After <---------+ +------------+ always +------------+ always +----------------+ always ``` ## Exiting To exit the application, use cli.Exit function, which accepts an exit code and exits the app with the provided code. It is important to use cli.Exit instead of os.Exit as the former ensures that all of the After interceptors are executed before exiting. ``` cli.Exit(1) ``` ## Spec Strings An App or Command's invocation syntax can be customized using spec strings. This can be useful to indicate that an argument is optional or that two options are mutually exclusive. The spec string is one of the key differentiators between this package and other CLI packages as it allows the developer to express usage in a simple, familiar, yet concise grammar. To define option and argument usage for the top-level App, assign a spec string to the App's Spec field: ``` cp := cli.App("cp", "Copy files around") cp.Spec = "[-R [-H | -L | -P]]" ``` Likewise, to define option and argument usage for a command or subcommand, assign a spec string to the Command's Spec field: ``` docker := cli.App("docker", "A self-sufficient runtime for linux containers") docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { cmd.Spec = "[-d|--rm] IMAGE [COMMAND [ARG...]]" : : } ``` The spec syntax is mostly based on the conventions used in POSIX command line applications (help messages and man pages). This syntax is described in full below. If a user invokes the app or command with the incorrect syntax, the app terminates with a help message showing the proper invocation. The remainder of this section describes the many features and capabilities of the spec string grammar. Options can use both short and long option names in spec strings. In the example below, the option is mandatory and must be provided. Any options referenced in a spec string MUST be explicitly declared, otherwise this package will panic. I.e. for each item in the spec string, a corresponding *Opt or *Arg is required: ``` x.Spec = "-f" // or x.Spec = "--force" forceFlag := x.BoolOpt("f force", ...) ``` Arguments are specified with all-uppercased words. In the example below, both SRC and DST must be provided by the user (two arguments). Like options, any argument referenced in a spec string MUST be explicitly declared, otherwise this package will panic: ``` x.Spec="SRC DST" src := x.StringArg("SRC", ...) dst := x.StringArg("DST", ...) ``` With the exception of options, the order of the elements in a spec string is respected and enforced when command line arguments are parsed. In the example below, consecutive options (-f and -g) are parsed regardless of the order they are specified (both "-f=5 -g=6" and "-g=6 -f=5" are valid). Order between options and arguments is significant (-f and -g must appear before the SRC argument). The same holds true for arguments, where SRC must appear before DST: ``` x.Spec = "-f -g SRC -h DST" var ( factor = x.IntOpt("f", 1, "Fun factor (1-5)") games = x.IntOpt("g", 1, "# of games") health = x.IntOpt("h", 1, "# of hosts") src = x.StringArg("SRC", ...) dst = x.StringArg("DST", ...) ) ``` Optionality of options and arguments is specified in a spec string by enclosing the item in square brackets []. If the user does not provide an optional value, the app will use the default value specified when the argument was defined. In the example below, if -x is not provided, heapSize will default to 1024: ``` x.Spec = "[-x]" heapSize := x.IntOpt("x", 1024, "Heap size in MB") ``` Choice between two or more items is specified in a spec string by separating each choice with the | operator. Choices are mutually exclusive. In the examples below, only a single choice can be provided by the user otherwise the app will terminate displaying a help message on proper usage: ``` x.Spec = "--rm | --daemon" x.Spec = "-H | -L | -P" x.Spec = "-t | DST" ``` Repetition of options and arguments is specified in a spec string with the ... postfix operator to mark an item as repeatable. Both options and arguments support repitition. In the example below, users may invoke the command with multiple -e options and multiple SRC arguments: ``` x.Spec = "-e... SRC..." // Allows parsing of the following shell command: // $ app -eeeee file1 file2 // $ app -e -e -e -e file1 file2 ``` Grouping of options and arguments is specified in a spec string with parenthesis. When combined with the choice | and repetition ... operators, complex syntaxes can be created. The parenthesis in the example below indicate a repeatable sequence of a -e option followed by an argument, and that is mutually exclusive to a choice between -x and -y options. ``` x.Spec = "(-e COMMAND)... | (-x|-y)" // Allows parsing of the following shell command: // $ app -e show -e add // $ app -y // But not the following: // $ app -e show -x ``` Option groups, or option folding, are a shorthand method to declaring a choice between multiple options. I.e. any combination of the listed options in any order with at least one option selected. The following two statements are equivalent: ``` x.Spec = "-abcd" x.Spec = "(-a | -b | -c | -d)..." ``` Option groups are typically used in conjunction with optionality [] operators. I.e. any combination of the listed options in any order or none at all. The following two statements are equivalent: ``` x.Spec = "[-abcd]" x.Spec = "[-a | -b | -c | -d]..." ``` All of the options can be specified using a special syntax: [OPTIONS]. This is a special token in the spec string (not optionality and not an argument called OPTIONS). It is equivalent to an optional repeatable choice between all the available options. For example, if an app or a command declares 4 options a, b, c and d, then the following two statements are equivalent: ``` x.Spec = "[OPTIONS]" x.Spec = "[-a | -b | -c | -d]..." ``` Inline option values are specified in the spec string with the = notation immediately following an option (long or short form) to provide users with an inline description or value. The actual inline values are ignored by the spec parser as they exist only to provide a contextual hint to the user. In the example below, "absolute-path" and "in seconds" are ignored by the parser: ``` x.Spec = "[ -a= | --timeout= ] ARG" ``` The -- operator can be used to automatically treat everything following it as arguments. In other words, placing a -- in the spec string automatically inserts a -- in the same position in the program call arguments. This lets you write programs such as the POSIX time utility for example: ``` x.Spec = "-lp [-- CMD [ARG...]]" // Allows parsing of the following shell command: // $ app -p ps -aux ``` ## Spec Grammar Below is the full EBNF grammar for the Specs language: ``` spec -> sequence sequence -> choice* req_sequence -> choice+ choice -> atom ('|' atom)* atom -> (shortOpt | longOpt | optSeq | allOpts | group | optional) rep? shortOp -> '-' [A-Za-z] longOpt -> '--' [A-Za-z][A-Za-z0-9]* optSeq -> '-' [A-Za-z]+ allOpts -> '[OPTIONS]' group -> '(' req_sequence ')' optional -> '[' req_sequence ']' rep -> '...' ``` By combining a few of these building blocks together (while respecting the grammar above), powerful and sophisticated validation constraints can be created in a simple and concise manner without having to define in code. This is one of the key differentiators between this package and other CLI packages. Validation of usage is handled entirely by the package through the spec string. Behind the scenes, this package parses the spec string and constructs a finite state machine used to parse the command line arguments. It also handles backtracking, which allows it to handle tricky cases, or what I like to call "the cp test": ``` cp SRC... DST ``` Without backtracking, this deceptively simple spec string cannot be parsed correctly. For instance, docopt can't handle this case, whereas this package does. ## Default Spec By default an auto-generated spec string is created for the app and every command unless a spec string has been set by the user. This can simplify use of the package even further for simple syntaxes. The following logic is used to create an auto-generated spec string: 1) start with an empty spec string, 2) if at least one option was declared, append "[OPTIONS]" to the spec string, and 3) for each declared argument, append it, in the order of declaration, to the spec string. For example, given this command declaration: ``` docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { var ( detached = cmd.BoolOpt("d detach", false, "Run container in background") memory = cmd.StringOpt("m memory", "", "Set memory limit") image = cmd.StringArg("IMAGE", "", "The image to run") args = cmd.StringsArg("ARG", nil, "Arguments") ) }) ``` The auto-generated spec string, which should suffice for simple cases, would be: ``` [OPTIONS] IMAGE ARG ``` If additional constraints are required, the spec string must be set explicitly using the grammar documented above. ## Custom Types By default, the following types are supported for options and arguments: bool, string, int, float64, strings (slice of strings), ints (slice of ints) and floats64 (slice of float64). You can, however, extend this package to handle other types, e.g. time.Duration, float64, or even your own struct types. To define your own custom type, you must implement the flag.Value interface for your custom type, and then declare the option or argument using VarOpt or VarArg respectively if using the short-form methods. If using the long-form struct, then use Var instead. The following example defines a custom type for a duration. It defines a duration argument that users will be able to invoke with strings in the form of "1h31m42s": ``` // Declare your type type Duration time.Duration // Make it implement flag.Value func (d *Duration) Set(v string) error { parsed, err := time.ParseDuration(v) if err != nil { return err } *d = Duration(parsed) return nil } func (d *Duration) String() string { duration := time.Duration(*d) return duration.String() } func main() { duration := Duration(0) app := App("var", "") app.VarArg("DURATION", &duration, "") app.Run([]string{"cp", "1h31m42s"}) } ``` To make a custom type to behave as a boolean option, i.e. doesn't take a value, it must implement the IsBoolFlag method that returns true: ``` type BoolLike int func (d *BoolLike) IsBoolFlag() bool { return true } ``` To make a custom type behave as a multi-valued option or argument, i.e. takes multiple values, it must implement the Clear method, which is called whenever the values list needs to be cleared, e.g. when the value was initially populated from an environment variable, and then explicitly set from the CLI: ``` type Durations []time.Duration // Make it implement flag.Value func (d *Durations) Set(v string) error { parsed, err := time.ParseDuration(v) if err != nil { return err } *d = append(*d, Duration(parsed)) return nil } func (d *Durations) String() string { return fmt.Sprintf("%v", *d) } // Make it multi-valued func (d *Durations) Clear() { *d = []Duration{} } ``` To hide the default value of a custom type, it must implement the IsDefault method that returns a boolean. The help message generator will use the return value to decide whether or not to display the default value to users: ``` type Action string func (a *Action) IsDefault() bool { return (*a) == "nop" } ``` ## License This work is published under the MIT license. Please see the `LICENSE` file for details. * * * Automatically generated by [autoreadme](https://github.com/jimmyfrasche/autoreadme) on 2019.02.24 mow.cli-1.1.0/README.md.template000066400000000000000000000232211346511200500161470ustar00rootroot00000000000000# mow.cli [![Build Status](https://travis-ci.org/{{.RepoPath}}.svg?branch=master)](https://travis-ci.org/{{.RepoPath}}) [![GoDoc](https://godoc.org/github.com/{{.Import}}?status.svg)](https://godoc.org/{{.Import}}) [![Coverage Status](https://coveralls.io/repos/github/{{.RepoPath}}/badge.svg?branch=master)](https://coveralls.io/github/{{.RepoPath}}?branch=master) {{.Synopsis}} ## Getting Started The following examples demonstrate basic usage the package. ### Simple Application In this simple application, we mimic the argument parsing of the standard UNIX cp command. Our application requires the user to specify one or more source files followed by a destination. An optional recursive flag may be provided. ```go package main import ( "fmt" "os" "github.com/jawher/mow.cli" ) func main() { // create an app app := cli.App("cp", "Copy files around") // Here's what differentiates mow.cli from other CLI libraries: // This line is not just for help message generation. // It also validates the call to reject calls with less than 2 arguments // and split the arguments between SRC or DST app.Spec = "[-r] SRC... DST" var ( // declare the -r flag as a boolean flag recursive = app.BoolOpt("r recursive", false, "Copy files recursively") // declare the SRC argument as a multi-string argument src = app.StringsArg("SRC", nil, "Source files to copy") // declare the DST argument as a single string (string slice) arguments dst = app.StringArg("DST", "", "Destination where to copy files to") ) // Specify the action to execute when the app is invoked correctly app.Action = func() { fmt.Printf("Copying %v to %s [recursively: %v]\n", *src, *dst, *recursive) } // Invoke the app passing in os.Args app.Run(os.Args) } ``` ### Pointers to existing variables This variant of the cp command uses the Ptr variants, where you can pass pointers to existing variables instead of declaring new ones for the options/arguments: ```go package main import ( "fmt" "os" cli "github.com/jawher/mow.cli" ) type Config struct { Recursive bool Src []string Dst string } func main() { var ( app = cli.App("cp", "Copy files around") cfg Config ) // Here's what differentiates mow.cli from other CLI libraries: // This line is not just for help message generation. // It also validates the call to reject calls with less than 2 arguments // and split the arguments between SRC or DST app.Spec = "[-r] SRC... DST" // declare the -r flag as a boolean flag app.BoolOptPtr(&cfg.Recursive, "r recursive", false, "Copy files recursively") // declare the SRC argument as a multi-string argument app.StringsArgPtr(&cfg.Src, "SRC", nil, "Source files to copy") // declare the DST argument as a single string (string slice) arguments app.StringArgPtr(&cfg.Dst, "DST", "", "Destination where to copy files to") // Specify the action to execute when the app is invoked correctly app.Action = func() { fmt.Printf("Copying using config: %+v\n", cfg) } // Invoke the app passing in os.Args app.Run(os.Args) } ``` ### Multi-Command Application In the next example, we create a multi-command application in the same style as familiar commands such as git and docker. We build a fictional utility called uman to manage users in a system. It provides two commands that can be invoked: list and get. The list command takes an optional flag to specify all users including disabled ones. The get command requries one argument, the user ID, and takes an optional flag to specify a detailed listing. ```go package main import ( "fmt" "os" "github.com/jawher/mow.cli" ) func main() { app := cli.App("uman", "User Manager") app.Spec = "[-v]" var ( verbose = app.BoolOpt("v verbose", false, "Verbose debug mode") ) app.Before = func() { if *verbose { // Here we can enable debug output in our logger for example fmt.Println("Verbose mode enabled") } } // Declare our first command, which is invocable with "uman list" app.Command("list", "list the users", func(cmd *cli.Cmd) { // These are the command-specific options and args, nicely scoped // inside a func so they don't pollute the namespace var ( all = cmd.BoolOpt("all", false, "List all users, including disabled") ) // Run this function when the command is invoked cmd.Action = func() { // Inside the action, and only inside, we can safely access the // values of the options and arguments fmt.Printf("user list (including disabled ones: %v)\n", *all) } }) // Declare our second command, which is invocable with "uman get" app.Command("get", "get a user details", func(cmd *cli.Cmd) { var ( detailed = cmd.BoolOpt("detailed", false, "Disaply detailed info") id = cmd.StringArg("ID", "", "The user id to display") ) cmd.Action = func() { fmt.Printf("user %q details (detailed mode: %v)\n", *id, *detailed) } }) // With the app configured, execute it, passing in the os.Args array app.Run(os.Args) } ``` ### A Larger Multi-Command Example This example shows an alternate way of organizing our code when dealing with a larger number of commands and subcommands. This layout emphasizes the command structure and defers the details of each command to subsequent functions. Like the prior examples, options and arguments are still scoped to their respective functions and don't pollute the global namespace. ```go package main import ( "fmt" "os" "github.com/jawher/mow.cli" ) // Global options available to any of the commands var filename *string func main() { app := cli.App("vault", "Password Keeper") // Define our top-level global options filename = app.StringOpt("f file", os.Getenv("HOME")+"/.safe", "Path to safe") // Define our command structure for usage like this: app.Command("list", "list accounts", cmdList) app.Command("creds", "display account credentials", cmdCreds) app.Command("config", "manage accounts", func(config *cli.Cmd) { config.Command("list", "list accounts", cmdList) config.Command("add", "add an account", cmdAdd) config.Command("remove", "remove an account(s)", cmdRemove) }) app.Run(os.Args) } // Sample use: vault list OR vault config list func cmdList(cmd *cli.Cmd) { cmd.Action = func() { fmt.Printf("list the contents of the safe here") } } // Sample use: vault creds reddit.com func cmdCreds(cmd *cli.Cmd) { cmd.Spec = "ACCOUNT" account := cmd.StringArg("ACCOUNT", "", "Name of account") cmd.Action = func() { fmt.Printf("display account info for %s\n", *account) } } // Sample use: vault config add reddit.com -u username -p password func cmdAdd(cmd *cli.Cmd) { cmd.Spec = "ACCOUNT [ -u= ] [ -p= ]" var ( account = cmd.StringArg("ACCOUNT", "", "Account name") username = cmd.StringOpt("u username", "admin", "Account username") password = cmd.StringOpt("p password", "admin", "Account password") ) cmd.Action = func() { fmt.Printf("Adding account %s:%s@%s", *username, *password, *account) } } // Sample use: vault config remove reddit.com twitter.com func cmdRemove(cmd *cli.Cmd) { cmd.Spec = "ACCOUNT..." var ( accounts = cmd.StringsArg("ACCOUNT", nil, "Account names to remove") ) cmd.Action = func() { fmt.Printf("Deleting accounts: %v", *accounts) } } ``` ## Comparison to Other Tools There are several tools in the Go ecosystem to facilitate the creation of command line tools. The following is a comparison to the built-in flag package as well as the popular urfave/cli (formerly known as codegangsta/cli): | | mow.cli | urfave/cli | flag | |---------------------------------------------------------------------|---------|------------|------| | Contextual help | ✓ | ✓ | | | Commands | ✓ | ✓ | | | Option folding `-xyz` | ✓ | | | | Option value folding `-fValue` | ✓ | | | | Option exclusion `--start ❘ --stop` | ✓ | | | | Option dependency `[-a -b]` or `[-a [-b]]` | ✓ | | | | Arguments validation `SRC DST` | ✓ | | | | Argument optionality `SRC [DST]` | ✓ | | | | Argument repetition `SRC... DST` | ✓ | | | | Option/argument dependency `SRC [-f DST]` | ✓ | | | | Any combination of the above `[-d ❘ --rm] IMAGE [COMMAND [ARG...]]` | ✓ | | | Unlike the simple packages above, docopt is another library that supports rich set of flag and argument validation. It does, however, fall short for many use cases including: | | mow.cli | docopt | |----------------------------|---------|--------| | Contextual help | ✓ | | | Backtracking `SRC... DST` | ✓ | | | Backtracking `[SRC] DST` | ✓ | | | Branching `(SRC ❘ -f DST)` | ✓ | | ## Installation To install this package, run the following: ```shell go get {{.Import}} ``` # Package Documentation {{.Doc}} {{if .Bugs}} # Bugs {{range .Bugs}}* {{.}}{{end}} {{end}} ## License This work is published under the MIT license. Please see the `LICENSE` file for details. * * * Automatically generated by [autoreadme](https://github.com/jimmyfrasche/autoreadme) on {{.Today}} mow.cli-1.1.0/args.go000066400000000000000000000337651346511200500143570ustar00rootroot00000000000000package cli import ( "flag" "fmt" "github.com/jawher/mow.cli/internal/lexer" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/values" ) // BoolArg describes a boolean argument type BoolArg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument EnvVar string // The argument's initial value Value bool // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a BoolArg) value(into *bool) (flag.Value, *bool) { if into == nil { into = new(bool) } return values.NewBool(into, a.Value), into } // StringArg describes a string argument type StringArg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument EnvVar string // The argument's initial value Value string // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a StringArg) value(into *string) (flag.Value, *string) { if into == nil { into = new(string) } return values.NewString(into, a.Value), into } // IntArg describes an int argument type IntArg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument EnvVar string // The argument's initial value Value int // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a IntArg) value(into *int) (flag.Value, *int) { if into == nil { into = new(int) } return values.NewInt(into, a.Value), into } // Float64Arg describes an float64 argument type Float64Arg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument EnvVar string // The argument's initial value Value float64 // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a Float64Arg) value(into *float64) (flag.Value, *float64) { if into == nil { into = new(float64) } return values.NewFloat64(into, a.Value), into } // StringsArg describes a string slice argument type StringsArg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument. // The env variable should contain a comma separated list of values EnvVar string // The argument's initial value Value []string // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a StringsArg) value(into *[]string) (flag.Value, *[]string) { if into == nil { into = new([]string) } return values.NewStrings(into, a.Value), into } // IntsArg describes an int slice argument type IntsArg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument. // The env variable should contain a comma separated list of values EnvVar string // The argument's initial value Value []int // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a IntsArg) value(into *[]int) (flag.Value, *[]int) { if into == nil { into = new([]int) } return values.NewInts(into, a.Value), into } // Floats64Arg describes an int slice argument type Floats64Arg struct { // The argument name as will be shown in help messages Name string // The argument description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this argument. // The env variable should contain a comma separated list of values EnvVar string // The argument's initial value Value []float64 // A boolean to display or not the current value of the argument in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a Floats64Arg) value(into *[]float64) (flag.Value, *[]float64) { if into == nil { into = new([]float64) } return values.NewFloats64(into, a.Value), into } // VarArg describes an argument where the type and format of the value is controlled by the developer type VarArg struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option EnvVar string // A value implementing the flag.Value type (will hold the final value) Value flag.Value // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this arg was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (a VarArg) value() flag.Value { return a.Value } /* BoolArg defines a boolean argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to a bool) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) BoolArg(name string, value bool, desc string) *bool { return c.Bool(BoolArg{ Name: name, Value: value, Desc: desc, }) } /* BoolArgPtr defines a boolean argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a bool) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) BoolArgPtr(into *bool, name string, value bool, desc string) { c.BoolPtr(into, BoolArg{ Name: name, Value: value, Desc: desc, }) } /* StringArg defines a string argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to a string) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringArg(name string, value string, desc string) *string { return c.String(StringArg{ Name: name, Value: value, Desc: desc, }) } /* StringArgPtr defines a string argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a string) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringArgPtr(into *string, name string, value string, desc string) { c.StringPtr(into, StringArg{ Name: name, Value: value, Desc: desc, }) } /* IntArg defines an int argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to an int) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntArg(name string, value int, desc string) *int { return c.Int(IntArg{ Name: name, Value: value, Desc: desc, }) } /* IntArgPtr defines an int argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a int) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntArgPtr(into *int, name string, value int, desc string) { c.IntPtr(into, IntArg{ Name: name, Value: value, Desc: desc, }) } /* Float64Arg defines an float64 argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to an float64) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Float64Arg(name string, value float64, desc string) *float64 { return c.Float64(Float64Arg{ Name: name, Value: value, Desc: desc, }) } /* Float64ArgPtr defines an float64 argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a float64) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Float64ArgPtr(into *float64, name string, value float64, desc string) { c.Float64Ptr(into, Float64Arg{ Name: name, Value: value, Desc: desc, }) } /* StringsArg defines a string slice argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to a string slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringsArg(name string, value []string, desc string) *[]string { return c.Strings(StringsArg{ Name: name, Value: value, Desc: desc, }) } /* StringsArgPtr defines a string slice argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a string slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringsArgPtr(into *[]string, name string, value []string, desc string) { c.StringsPtr(into, StringsArg{ Name: name, Value: value, Desc: desc, }) } /* IntsArg defines an int slice argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to an int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntsArg(name string, value []int, desc string) *[]int { return c.Ints(IntsArg{ Name: name, Value: value, Desc: desc, }) } /* IntsArgPtr defines a int slice argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntsArgPtr(into *[]int, name string, value []int, desc string) { c.IntsPtr(into, IntsArg{ Name: name, Value: value, Desc: desc, }) } /* Floats64Arg defines an float64 slice argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The result should be stored in a variable (a pointer to an float64 slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Floats64Arg(name string, value []float64, desc string) *[]float64 { return c.Floats64(Floats64Arg{ Name: name, Value: value, Desc: desc, }) } /* Floats64ArgPtr defines a float64 slice argument on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The into parameter points to a variable (a pointer to a float64 slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Floats64ArgPtr(into *[]float64, name string, value []float64, desc string) { c.Floats64Ptr(into, Floats64Arg{ Name: name, Value: value, Desc: desc, }) } /* VarArg defines an argument where the type and format is controlled by the developer on the command c named `name` and a description of `desc` which will be used in help messages. The result will be stored in the value parameter (a value implementing the flag.Value interface) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) VarArg(name string, value flag.Value, desc string) { c.mkArg(container.Container{Name: name, Desc: desc, Value: value}) } func (c *Cmd) mkArg(arg container.Container) { if !validArgName(arg.Name) { panic(fmt.Sprintf("invalid argument name %q: must be in all caps", arg.Name)) } if _, found := c.argsIdx[arg.Name]; found { panic(fmt.Sprintf("duplicate argument name %q", arg.Name)) } arg.ValueSetFromEnv = values.SetFromEnv(arg.Value, arg.EnvVar) c.args = append(c.args, &arg) c.argsIdx[arg.Name] = &arg } func validArgName(n string) bool { tokens, err := lexer.Tokenize(n) if err != nil { return false } if len(tokens) != 1 { return false } return tokens[0].Typ == lexer.TTArg } mow.cli-1.1.0/cli.go000066400000000000000000000062401346511200500141560ustar00rootroot00000000000000package cli import ( "flag" "fmt" "io" "os" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/flow" ) /* Cli represents the structure of a CLI app. It should be constructed using the App() function */ type Cli struct { *Cmd version *cliVersion } type cliVersion struct { version string option *container.Container } /* App creates a new and empty CLI app configured with the passed name and description. name and description will be used to construct the help message for the app: Usage: $name [OPTIONS] COMMAND [arg...] $desc */ func App(name, desc string) *Cli { return &Cli{ Cmd: &Cmd{ name: name, desc: desc, optionsIdx: map[string]*container.Container{}, argsIdx: map[string]*container.Container{}, ErrorHandling: flag.ExitOnError, }, } } /* Version sets the version string of the CLI app together with the options that can be used to trigger printing the version string via the CLI. Usage: appName --$name $version */ func (cli *Cli) Version(name, version string) { cli.Bool(BoolOpt{ Name: name, Value: false, Desc: "Show the version and exit", HideValue: true, }) names := mkOptStrs(name) option := cli.optionsIdx[names[0]] cli.version = &cliVersion{version, option} } func (cli *Cli) parse(args []string, entry, inFlow, outFlow *flow.Step) error { // We overload Cmd.parse() and handle cases that only apply to the CLI command, like versioning // After that, we just call Cmd.parse() for the default behavior if cli.versionSetAndRequested(args) { cli.PrintVersion() cli.onError(errVersionRequested) return nil } return cli.Cmd.parse(args, entry, inFlow, outFlow) } func (cli *Cli) versionSetAndRequested(args []string) bool { return cli.version != nil && cli.isFlagSet(args, cli.version.option.Names) } /* PrintVersion prints the CLI app's version. In most cases the library users won't need to call this method, unless a more complex validation is needed. */ func (cli *Cli) PrintVersion() { fmt.Fprintln(stdErr, cli.version.version) } /* Run uses the app configuration (specs, commands, ...) to parse the args slice and to execute the matching command. In case of an incorrect usage, and depending on the configured ErrorHandling policy, it may return an error, panic or exit */ func (cli *Cli) Run(args []string) error { if err := cli.doInit(); err != nil { panic(err) } inFlow := &flow.Step{Desc: "RootIn", Exiter: exiter} outFlow := &flow.Step{Desc: "RootOut", Exiter: exiter} return cli.parse(args[1:], inFlow, inFlow, outFlow) } /* ActionCommand is a convenience function to configure a command with an action. cmd.ActionCommand(_, _, myFunc) is equivalent to cmd.Command(_, _, func(cmd *cli.Cmd) { cmd.Action = myFunc }) */ func ActionCommand(action func()) CmdInitializer { return func(cmd *Cmd) { cmd.Action = action } } /* Exit causes the app the exit with the specified exit code while giving the After interceptors a chance to run. This should be used instead of os.Exit. */ func Exit(code int) { panic(flow.ExitCode(code)) } var exiter = func(code int) { os.Exit(code) } var ( stdOut io.Writer = os.Stdout stdErr io.Writer = os.Stderr ) mow.cli-1.1.0/cli_test.go000066400000000000000000001622221346511200500152200ustar00rootroot00000000000000package cli import ( "bytes" "flag" "github.com/stretchr/testify/require" "io/ioutil" "os" "reflect" "testing" "fmt" "github.com/jawher/mow.cli/internal/flow" ) func TestTheCpCase(t *testing.T) { app := App("cp", "") app.Spec = "SRC... DST" src := app.Strings(StringsArg{Name: "SRC", Value: nil, Desc: ""}) dst := app.String(StringArg{Name: "DST", Value: "", Desc: ""}) ex := false app.Action = func() { ex = true require.Equal(t, []string{"x", "y"}, *src) require.Equal(t, "z", *dst) } require.NoError(t, app.Run([]string{"cp", "x", "y", "z"})) require.True(t, ex, "Exec wasn't called") } func TestImplicitSpec(t *testing.T) { app := App("test", "") x := app.Bool(BoolOpt{Name: "x", Value: false, Desc: ""}) y := app.String(StringOpt{Name: "y", Value: "", Desc: ""}) called := false app.Action = func() { called = true } app.ErrorHandling = flag.ContinueOnError err := app.Run([]string{"test", "-x", "-y", "hello"}) require.NoError(t, err) require.True(t, *x) require.Equal(t, "hello", *y) require.True(t, called, "Exec wasn't called") } func TestExit(t *testing.T) { defer func() { if p := recover(); p != nil { t.Logf("Panicked with %v", p) require.Equal(t, flow.ExitCode(666), p) return } t.Fatalf("Should have panicked") }() Exit(666) t.Fatalf("Should have panicked") } func TestInvalidSpec(t *testing.T) { app := App("test", "") app.Spec = "X" called := false app.Action = func() { called = true } defer func() { if p := recover(); p != nil { t.Logf("Panicked with %v", p) require.False(t, called, "action should not have been called") return } t.Fatalf("Should have panicked") }() require.NoError(t, app.Run([]string{"test", "-x", "-y", "hello"})) t.Fatalf("Should have panicked") } func TestDuplicateOptionName(t *testing.T) { defer func() { if p := recover(); p != nil { t.Logf("Panicked with %v", p) return } t.Fatalf("Should have panicked") }() app := App("test", "") app.BoolOpt("f force", false, "") app.StringOpt("f file", "", "") t.Fatalf("Should have panicked") } func TestDuplicateArgName(t *testing.T) { defer func() { if p := recover(); p != nil { t.Logf("Panicked with %v", p) return } t.Fatalf("Should have panicked") }() app := App("test", "") app.StringArg("ARG", "", "") app.StringArg("ARG", "", "") t.Fatalf("Should have panicked") } func TestInvalidArgName(t *testing.T) { defer func() { if p := recover(); p != nil { t.Logf("Panicked with %v", p) return } t.Fatalf("Should have panicked") }() app := App("test", "") app.StringArg("arg", "", "") t.Fatalf("Should have panicked") } func runAppAndCheckValue(t *testing.T, name string, callArgs []string, expected interface{}, appConfigurer func(app *Cli) interface{}) { t.Run(fmt.Sprintf("%s %+v", name, callArgs), func(t *testing.T) { t.Logf("Testing %+v", callArgs) app := App("app", "") app.ErrorHandling = flag.ContinueOnError opt := appConfigurer(app) ex := false app.Action = func() { ex = true require.Equal(t, expected, reflect.ValueOf(opt).Elem().Interface()) } err := app.Run(callArgs) require.NoError(t, err) require.True(t, ex, "Exec wasn't called") }) } func TestAppWithBoolOption(t *testing.T) { cases := []struct { args []string expectedOptValue bool }{ {[]string{"app"}, false}, {[]string{"app", "-o"}, true}, {[]string{"app", "-o=true"}, true}, {[]string{"app", "-o=false"}, false}, {[]string{"app", "--option"}, true}, {[]string{"app", "--option=true"}, true}, {[]string{"app", "--option=false"}, false}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.BoolOpt("o option", false, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Bool(BoolOpt{ Name: "o option", }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val bool app.BoolOptPtr(&val, "o option", false, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val bool app.BoolPtr(&val, BoolOpt{ Name: "o option", }) return &val }) } } func TestAppWithStringOption(t *testing.T) { cases := []struct { args []string expectedOptValue string }{ {[]string{"app"}, "default"}, {[]string{"app", "-o", "user"}, "user"}, {[]string{"app", "-o=user"}, "user"}, {[]string{"app", "--option", "user"}, "user"}, {[]string{"app", "--option=user"}, "user"}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.StringOpt("o option", "default", "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.String(StringOpt{ Name: "o option", Value: "default", }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val string app.StringOptPtr(&val, "o option", "default", "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val string app.StringPtr(&val, StringOpt{ Name: "o option", Value: "default", }) return &val }) } } func TestAppWithIntOption(t *testing.T) { cases := []struct { args []string expectedOptValue int }{ {[]string{"app"}, 3}, {[]string{"app", "-o", "16"}, 16}, {[]string{"app", "-o=16"}, 16}, {[]string{"app", "--option", "16"}, 16}, {[]string{"app", "--option=16"}, 16}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.IntOpt("o option", 3, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Int(IntOpt{ Name: "o option", Value: 3, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val int app.IntOptPtr(&val, "o option", 3, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val int app.IntPtr(&val, IntOpt{ Name: "o option", Value: 3, }) return &val }) } } func TestAppWithFloat64Option(t *testing.T) { cases := []struct { args []string expectedOptValue float64 }{ {[]string{"app"}, 3.14}, {[]string{"app", "-o", "16.0001"}, 16.0001}, {[]string{"app", "-o=16.0001"}, 16.0001}, {[]string{"app", "--option", "16.0001"}, 16.0001}, {[]string{"app", "--option=16.0001"}, 16.0001}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Float64Opt("o option", 3.14, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Float64(Float64Opt{ Name: "o option", Value: 3.14, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val float64 app.Float64OptPtr(&val, "o option", 3.14, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val float64 app.Float64Ptr(&val, Float64Opt{ Name: "o option", Value: 3.14, }) return &val }) } } func TestAppWithStringsOption(t *testing.T) { cases := []struct { args []string expectedOptValue []string }{ {[]string{"app"}, []string{"a", "b"}}, {[]string{"app", "-o", "x"}, []string{"x"}}, {[]string{"app", "-o", "x", "-o=y"}, []string{"x", "y"}}, {[]string{"app", "--option", "x"}, []string{"x"}}, {[]string{"app", "--option", "x", "--option=y"}, []string{"x", "y"}}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.StringsOpt("o option", []string{"a", "b"}, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Strings(StringsOpt{ Name: "o option", Value: []string{"a", "b"}, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val []string app.StringsOptPtr(&val, "o option", []string{"a", "b"}, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val []string app.StringsPtr(&val, StringsOpt{ Name: "o option", Value: []string{"a", "b"}, }) return &val }) } } func TestAppWithIntsOption(t *testing.T) { cases := []struct { args []string expectedOptValue []int }{ {[]string{"app"}, []int{1, 2}}, {[]string{"app", "-o", "10"}, []int{10}}, {[]string{"app", "-o", "10", "-o=11"}, []int{10, 11}}, {[]string{"app", "--option", "10"}, []int{10}}, {[]string{"app", "--option", "10", "--option=11"}, []int{10, 11}}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.IntsOpt("o option", []int{1, 2}, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Ints(IntsOpt{ Name: "o option", Value: []int{1, 2}, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val []int app.IntsOptPtr(&val, "o option", []int{1, 2}, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val []int app.IntsPtr(&val, IntsOpt{ Name: "o option", Value: []int{1, 2}, }) return &val }) } } func TestAppWithFloats64Option(t *testing.T) { cases := []struct { args []string expectedOptValue []float64 }{ {[]string{"app"}, []float64{1.1, 2.2}}, {[]string{"app", "-o", "10.05"}, []float64{10.05}}, {[]string{"app", "-o", "10.05", "-o=11.993"}, []float64{10.05, 11.993}}, {[]string{"app", "--option", "10.05"}, []float64{10.05}}, {[]string{"app", "--option", "10.05", "--option=11.993"}, []float64{10.05, 11.993}}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Floats64Opt("o option", []float64{1.1, 2.2}, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { return app.Floats64(Floats64Opt{ Name: "o option", Value: []float64{1.1, 2.2}, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val []float64 app.Floats64OptPtr(&val, "o option", []float64{1.1, 2.2}, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedOptValue, func(app *Cli) interface{} { var val []float64 app.Floats64Ptr(&val, Floats64Opt{ Name: "o option", Value: []float64{1.1, 2.2}, }) return &val }) } } func TestAppWithBoolArg(t *testing.T) { cases := []struct { args []string expectedArgValue bool }{ {[]string{"app"}, false}, {[]string{"app", "true"}, true}, {[]string{"app", "false"}, false}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.BoolArg("ARG", false, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.Bool(BoolArg{ Name: "ARG", }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val bool app.BoolArgPtr(&val, "ARG", false, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val bool app.BoolPtr(&val, BoolArg{ Name: "ARG", }) return &val }) } } func TestAppWithStringArg(t *testing.T) { cases := []struct { args []string expectedArgValue string }{ {[]string{"app"}, "default"}, {[]string{"app", "user"}, "user"}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.StringArg("ARG", "default", "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.String(StringArg{ Name: "ARG", Value: "default", }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val string app.StringArgPtr(&val, "ARG", "default", "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val string app.StringPtr(&val, StringArg{ Name: "ARG", Value: "default", }) return &val }) } } func TestAppWithIntArg(t *testing.T) { cases := []struct { args []string expectedArgValue int }{ {[]string{"app"}, 3}, {[]string{"app", "16"}, 16}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.IntArg("ARG", 3, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.Int(IntArg{ Name: "ARG", Value: 3, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val int app.IntArgPtr(&val, "ARG", 3, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val int app.IntPtr(&val, IntArg{ Name: "ARG", Value: 3, }) return &val }) } } func TestAppWithFloat64Arg(t *testing.T) { cases := []struct { args []string expectedArgValue float64 }{ {[]string{"app"}, 3.14}, {[]string{"app", "16.123456789"}, 16.123456789}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.Float64Arg("ARG", 3.14, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" return app.Float64(Float64Arg{ Name: "ARG", Value: 3.14, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val float64 app.Float64ArgPtr(&val, "ARG", 3.14, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG]" var val float64 app.Float64Ptr(&val, Float64Arg{ Name: "ARG", Value: 3.14, }) return &val }) } } func TestAppWithStringsArg(t *testing.T) { cases := []struct { args []string expectedArgValue []string }{ {[]string{"app"}, []string{"a", "b"}}, {[]string{"app", "x"}, []string{"x"}}, {[]string{"app", "x", "y"}, []string{"x", "y"}}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" return app.StringsArg("ARG", []string{"a", "b"}, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" return app.Strings(StringsArg{ Name: "ARG", Value: []string{"a", "b"}, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" var val []string app.StringsArgPtr(&val, "ARG", []string{"a", "b"}, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" var val []string app.StringsPtr(&val, StringsArg{ Name: "ARG", Value: []string{"a", "b"}, }) return &val }) } } func TestAppWithIntsArg(t *testing.T) { cases := []struct { args []string expectedArgValue []int }{ {[]string{"app"}, []int{1, 2}}, {[]string{"app", "10"}, []int{10}}, {[]string{"app", "10", "11"}, []int{10, 11}}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" return app.IntsArg("ARG", []int{1, 2}, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" return app.Ints(IntsArg{ Name: "ARG", Value: []int{1, 2}, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" var val []int app.IntsArgPtr(&val, "ARG", []int{1, 2}, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" var val []int app.IntsPtr(&val, IntsArg{ Name: "ARG", Value: []int{1, 2}, }) return &val }) } } func TestAppWithFloats64Arg(t *testing.T) { cases := []struct { args []string expectedArgValue []float64 }{ {[]string{"app"}, []float64{1.1, 2.2}}, {[]string{"app", "10.123"}, []float64{10.123}}, {[]string{"app", "10.123", "11.995"}, []float64{10.123, 11.995}}, } for _, cas := range cases { runAppAndCheckValue(t, "short", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" return app.Floats64Arg("ARG", []float64{1.1, 2.2}, "") }) runAppAndCheckValue(t, "struct", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" return app.Floats64(Floats64Arg{ Name: "ARG", Value: []float64{1.1, 2.2}, }) }) runAppAndCheckValue(t, "short-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" var val []float64 app.Floats64ArgPtr(&val, "ARG", []float64{1.1, 2.2}, "") return &val }) runAppAndCheckValue(t, "struct-ptr", cas.args, cas.expectedArgValue, func(app *Cli) interface{} { app.Spec = "[ARG...]" var val []float64 app.Floats64Ptr(&val, Floats64Arg{ Name: "ARG", Value: []float64{1.1, 2.2}, }) return &val }) } } func testHelpAndVersionWithOptionsEnd(flag string, t *testing.T) { t.Logf("Testing help/version with --: flag=%q", flag) defer suppressOutput()() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("x", "") app.Version("v version", "1.0") app.Spec = "CMD" cmd := app.String(StringArg{Name: "CMD", Value: "", Desc: ""}) actionCalled := false app.Action = func() { actionCalled = true require.Equal(t, flag, *cmd) } require.NoError(t, app.Run([]string{"x", "--", flag})) require.True(t, actionCalled, "action should have been called") require.False(t, exitCalled, "exit should not have been called") } func TestHelpAndVersionWithOptionsEnd(t *testing.T) { for _, flag := range []string{"-h", "--help", "-v", "--version"} { testHelpAndVersionWithOptionsEnd(flag, t) } } var genGolden = flag.Bool("g", false, "Generate golden file(s)") func TestHelpMessage(t *testing.T) { var out, err string defer captureAndRestoreOutput(&out, &err)() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("app", "App Desc") app.Spec = "[-bdsuikqs] BOOL1 [STR1] INT3..." // Options app.Bool(BoolOpt{Name: "b bool1 u uuu", Value: false, EnvVar: "BOOL1", Desc: "Bool Option 1"}) app.Bool(BoolOpt{Name: "bool2", Value: true, EnvVar: " ", Desc: "Bool Option 2"}) app.Bool(BoolOpt{Name: "d", Value: true, EnvVar: "BOOL3", Desc: "Bool Option 3", HideValue: true}) app.String(StringOpt{Name: "s str1", Value: "", EnvVar: "STR1", Desc: "String Option 1"}) app.String(StringOpt{Name: "str2", Value: "a value", Desc: "String Option 2"}) app.String(StringOpt{Name: "v", Value: "another value", EnvVar: "STR3", Desc: "String Option 3", HideValue: true}) app.Int(IntOpt{Name: "i int1", Value: 0, EnvVar: "INT1 ALIAS_INT1"}) app.Int(IntOpt{Name: "int2", Value: 1, EnvVar: "INT2", Desc: "Int Option 2"}) app.Int(IntOpt{Name: "k", Value: 1, EnvVar: "INT3", Desc: "Int Option 3", HideValue: true}) app.Strings(StringsOpt{Name: "x strs1", Value: nil, EnvVar: "STRS1", Desc: "Strings Option 1"}) app.Strings(StringsOpt{Name: "strs2", Value: []string{"value1", "value2"}, EnvVar: "STRS2", Desc: "Strings Option 2"}) app.Strings(StringsOpt{Name: "z", Value: []string{"another value"}, EnvVar: "STRS3", Desc: "Strings Option 3", HideValue: true}) app.Ints(IntsOpt{Name: "q ints1", Value: nil, EnvVar: "INTS1", Desc: "Ints Option 1"}) app.Ints(IntsOpt{Name: "ints2", Value: []int{1, 2, 3}, EnvVar: "INTS2", Desc: "Ints Option 2"}) app.Ints(IntsOpt{Name: "j", Value: []int{1}, EnvVar: "INTS3", Desc: "Ints Option 3", HideValue: true}) // Args app.Bool(BoolArg{Name: "BOOL1", Value: false, EnvVar: "BOOL1", Desc: "Bool Argument 1"}) app.Bool(BoolArg{Name: "BOOL2", Value: true, Desc: "Bool Argument 2"}) app.Bool(BoolArg{Name: "BOOL3", Value: true, EnvVar: "BOOL3", Desc: "Bool Argument 3", HideValue: true}) app.String(StringArg{Name: "STR1", Value: "", EnvVar: "STR1", Desc: "String Argument 1"}) app.String(StringArg{Name: "STR2", Value: "a value", EnvVar: "STR2", Desc: "String Argument 2"}) app.String(StringArg{Name: "STR3", Value: "another value", EnvVar: "STR3", Desc: "String Argument 3", HideValue: true}) app.Int(IntArg{Name: "INT1", Value: 0, EnvVar: "INT1", Desc: "Int Argument 1"}) app.Int(IntArg{Name: "INT2", Value: 1, EnvVar: "INT2", Desc: "Int Argument 2"}) app.Int(IntArg{Name: "INT3", Value: 1, EnvVar: "INT3", Desc: "Int Argument 3", HideValue: true}) app.Strings(StringsArg{Name: "STRS1", Value: nil, EnvVar: "STRS1", Desc: "Strings Argument 1"}) app.Strings(StringsArg{Name: "STRS2", Value: []string{"value1", "value2"}, EnvVar: "STRS2"}) app.Strings(StringsArg{Name: "STRS3", Value: []string{"another value"}, EnvVar: "STRS3", Desc: "Strings Argument 3", HideValue: true}) app.Ints(IntsArg{Name: "INTS1", Value: nil, EnvVar: "INTS1", Desc: "Ints Argument 1"}) app.Ints(IntsArg{Name: "INTS2", Value: []int{1, 2, 3}, EnvVar: "INTS2", Desc: "Ints Argument 2"}) app.Ints(IntsArg{Name: "INTS3", Value: []int{1}, EnvVar: "INTS3", Desc: "Ints Argument 3", HideValue: true}) app.Action = func() {} app.Command("command1", "command1 description", func(cmd *Cmd) {}) app.Command("command2", "command2 description", func(cmd *Cmd) {}) app.Command("command3", "command3 description", func(cmd *Cmd) {}) require.NoError(t, app.Run([]string{"app", "-h"})) if *genGolden { require.NoError(t, ioutil.WriteFile("testdata/help-output.txt.golden", []byte(err), 0644)) } expected, e := ioutil.ReadFile("testdata/help-output.txt") require.NoError(t, e, "Failed to read the expected help output from testdata/help-output.txt") require.Equal(t, expected, []byte(err)) } func TestLongHelpMessage(t *testing.T) { var out, err string defer captureAndRestoreOutput(&out, &err)() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("app", "App Desc") app.LongDesc = "Longer App Desc" app.Spec = "[-o] ARG" app.String(StringOpt{Name: "o opt", Value: "", Desc: "Option"}) app.String(StringArg{Name: "ARG", Value: "", Desc: "Argument"}) app.Action = func() {} require.NoError(t, app.Run([]string{"app", "-h"})) if *genGolden { require.NoError(t, ioutil.WriteFile("testdata/long-help-output.txt.golden", []byte(err), 0644)) } expected, e := ioutil.ReadFile("testdata/long-help-output.txt") require.NoError(t, e, "Failed to read the expected help output from testdata/long-help-output.txt") require.Equal(t, expected, []byte(err)) } func TestMultiLineDescInHelpMessage(t *testing.T) { var out, err string defer captureAndRestoreOutput(&out, &err)() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("app", "App Desc") app.LongDesc = "Longer App Desc" app.Spec = "[-o] ARG" app.String(StringOpt{Name: "o opt", Value: "default", EnvVar: "XXX_TEST", Desc: "Option\ndoes something\n another line"}) app.Bool(BoolOpt{Name: "f force", Value: false, EnvVar: "YYY_TEST", Desc: "Force\ndoes something\n another line"}) app.String(StringArg{Name: "ARG", Value: "", Desc: "Argument\nDescription\nMultiple\nLines"}) app.Action = func() {} require.NoError(t, app.Run([]string{"app", "-h"})) if *genGolden { require.NoError(t, ioutil.WriteFile("testdata/multi-line-desc-help-output.txt.golden", []byte(err), 0644)) } expected, e := ioutil.ReadFile("testdata/multi-line-desc-help-output.txt") require.NoError(t, e, "Failed to read the expected help output from testdata/long-help-output.txt") require.Equal(t, expected, []byte(err)) } func TestVersionShortcut(t *testing.T) { defer suppressOutput()() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("cp", "") app.Version("v version", "cp 1.2.3") actionCalled := false app.Action = func() { actionCalled = true } require.NoError(t, app.Run([]string{"cp", "--version"})) require.False(t, actionCalled, "action should not have been called") require.True(t, exitCalled, "exit should have been called") } func TestSubCommands(t *testing.T) { app := App("say", "") hi, bye := false, false app.Command("hi", "", func(cmd *Cmd) { cmd.Action = func() { hi = true } }) app.Command("byte", "", func(cmd *Cmd) { cmd.Action = func() { bye = true } }) require.NoError(t, app.Run([]string{"say", "hi"})) require.True(t, hi, "hi should have been called") require.False(t, bye, "byte should NOT have been called") } func TestContinueOnError(t *testing.T) { defer exitShouldNotCalled(t)() defer suppressOutput()() app := App("say", "") app.String(StringOpt{Name: "f", Value: "", Desc: ""}) app.Spec = "-f" app.ErrorHandling = flag.ContinueOnError called := false app.Action = func() { called = true } err := app.Run([]string{"say"}) require.NotNil(t, err) require.False(t, called, "Exec should NOT have been called") } func TestContinueOnErrorWithHelpAndVersion(t *testing.T) { defer exitShouldNotCalled(t)() defer suppressOutput()() app := App("say", "") app.Version("v", "1.0") app.String(StringOpt{Name: "f", Value: "", Desc: ""}) app.Spec = "-f" app.ErrorHandling = flag.ContinueOnError called := false app.Action = func() { called = true } { err := app.Run([]string{"say", "-h"}) require.Nil(t, err) require.False(t, called, "Exec should NOT have been called") } { err := app.Run([]string{"say", "-v"}) require.Nil(t, err) require.False(t, called, "Exec should NOT have been called") } } func TestExitOnError(t *testing.T) { defer suppressOutput()() exitCalled := false defer exitShouldBeCalledWith(t, 2, &exitCalled)() app := App("x", "") app.ErrorHandling = flag.ExitOnError app.Spec = "Y" app.String(StringArg{Name: "Y", Value: "", Desc: ""}) require.Error(t, app.Run([]string{"x", "y", "z"})) require.True(t, exitCalled, "exit should have been called") } func TestExitOnErrorWithHelp(t *testing.T) { defer suppressOutput()() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("x", "") app.Spec = "Y" app.ErrorHandling = flag.ExitOnError app.String(StringArg{Name: "Y", Value: "", Desc: ""}) require.NoError(t, app.Run([]string{"x", "-h"})) require.True(t, exitCalled, "exit should have been called") } func TestExitOnErrorWithVersion(t *testing.T) { defer suppressOutput()() exitCalled := false defer exitShouldBeCalledWith(t, 0, &exitCalled)() app := App("x", "") app.Version("v", "1.0") app.Spec = "Y" app.ErrorHandling = flag.ExitOnError app.String(StringArg{Name: "Y", Value: "", Desc: ""}) require.NoError(t, app.Run([]string{"x", "-v"})) require.True(t, exitCalled, "exit should have been called") } func TestPanicOnError(t *testing.T) { defer suppressOutput()() app := App("say", "") app.String(StringOpt{Name: "f", Value: "", Desc: ""}) app.Spec = "-f" app.ErrorHandling = flag.PanicOnError called := false app.Action = func() { called = true } defer func() { if r := recover(); r != nil { require.False(t, called, "Exec should NOT have been called") } }() require.NoError(t, app.Run([]string{"say"})) t.Fatalf("wanted panic") } func TestOptSetByUser(t *testing.T) { cases := []struct { desc string config func(*Cli, *bool) args []string expected bool }{ // OPTS // String { desc: "String Opt, not set by user, default value", config: func(c *Cli, s *bool) { c.String(StringOpt{Name: "f", Value: "a", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "String Opt, not set by user, env value", config: func(c *Cli, s *bool) { os.Setenv("MOW_VALUE", "value") c.String(StringOpt{Name: "f", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "String Opt, set by user", config: func(c *Cli, s *bool) { c.String(StringOpt{Name: "f", Value: "a", SetByUser: s}) }, args: []string{"test", "-f=hello"}, expected: true, }, // Bool { desc: "Bool Opt, not set by user, default value", config: func(c *Cli, s *bool) { c.Bool(BoolOpt{Name: "f", Value: true, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Bool Opt, not set by user, env value", config: func(c *Cli, s *bool) { os.Setenv("MOW_VALUE", "true") c.Bool(BoolOpt{Name: "f", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Bool Opt, set by user", config: func(c *Cli, s *bool) { c.Bool(BoolOpt{Name: "f", SetByUser: s}) }, args: []string{"test", "-f"}, expected: true, }, // Int { desc: "Int Opt, not set by user, default value", config: func(c *Cli, s *bool) { c.Int(IntOpt{Name: "f", Value: 42, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Int Opt, not set by user, env value", config: func(c *Cli, s *bool) { os.Setenv("MOW_VALUE", "33") c.Int(IntOpt{Name: "f", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Int Opt, set by user", config: func(c *Cli, s *bool) { c.Int(IntOpt{Name: "f", SetByUser: s}) }, args: []string{"test", "-f=666"}, expected: true, }, // Ints { desc: "Ints Opt, not set by user, default value", config: func(c *Cli, s *bool) { c.Ints(IntsOpt{Name: "f", Value: []int{42}, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Ints Opt, not set by user, env value", config: func(c *Cli, s *bool) { os.Setenv("MOW_VALUE", "11,22,33") c.Ints(IntsOpt{Name: "f", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Ints Opt, set by user", config: func(c *Cli, s *bool) { c.Ints(IntsOpt{Name: "f", SetByUser: s}) }, args: []string{"test", "-f=666"}, expected: true, }, // Strings { desc: "Strings Opt, not set by user, default value", config: func(c *Cli, s *bool) { c.Strings(StringsOpt{Name: "f", Value: []string{"aaa"}, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Strings Opt, not set by user, env value", config: func(c *Cli, s *bool) { os.Setenv("MOW_VALUE", "a,b,c") c.Strings(StringsOpt{Name: "f", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Strings Opt, set by user", config: func(c *Cli, s *bool) { c.Strings(StringsOpt{Name: "f", SetByUser: s}) }, args: []string{"test", "-f=ccc"}, expected: true, }, } for _, cas := range cases { t.Run(cas.desc, func(t *testing.T) { t.Log(cas.desc) setByUser := false app := App("test", "") cas.config(app, &setByUser) called := false app.Action = func() { called = true } require.NoError(t, app.Run(cas.args)) require.True(t, called, "action should have been called") require.Equal(t, cas.expected, setByUser) }) } } func TestArgSetByUser(t *testing.T) { cases := []struct { desc string config func(*Cli, *bool) args []string expected bool }{ // ARGS // String { desc: "String Arg, not set by user, default value", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" c.String(StringArg{Name: "ARG", Value: "a", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "String Arg, not set by user, env value", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "value") c.String(StringArg{Name: "ARG", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "String Arg, set by user", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" c.String(StringArg{Name: "ARG", Value: "a", SetByUser: s}) }, args: []string{"test", "aaa"}, expected: true, }, // Bool { desc: "Bool Arg, not set by user, default value", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" c.Bool(BoolArg{Name: "ARG", Value: true, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Bool Arg, not set by user, env value", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "true") c.Bool(BoolArg{Name: "ARG", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Bool Arg, set by user", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" c.Bool(BoolArg{Name: "ARG", SetByUser: s}) }, args: []string{"test", "true"}, expected: true, }, // Int { desc: "Int Arg, not set by user, default value", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" c.Int(IntArg{Name: "ARG", Value: 42, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Int Arg, not set by user, env value", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "33") c.Int(IntArg{Name: "ARG", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Int Arg, set by user", config: func(c *Cli, s *bool) { c.Spec = "[ARG]" c.Int(IntArg{Name: "ARG", SetByUser: s}) }, args: []string{"test", "666"}, expected: true, }, // Ints { desc: "Ints Arg, not set by user, default value", config: func(c *Cli, s *bool) { c.Spec = "[ARG...]" c.Ints(IntsArg{Name: "ARG", Value: []int{42}, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Ints Arg, not set by user, env value", config: func(c *Cli, s *bool) { c.Spec = "[ARG...]" os.Setenv("MOW_VALUE", "11,22,33") c.Ints(IntsArg{Name: "ARG", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Ints Arg, set by user", config: func(c *Cli, s *bool) { c.Spec = "[ARG...]" c.Ints(IntsArg{Name: "ARG", SetByUser: s}) }, args: []string{"test", "333", "666"}, expected: true, }, // Strings { desc: "Strings Arg, not set by user, default value", config: func(c *Cli, s *bool) { c.Spec = "[ARG...]" c.Strings(StringsArg{Name: "ARG", Value: []string{"aaa"}, SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Strings Arg, not set by user, env value", config: func(c *Cli, s *bool) { c.Spec = "[ARG...]" os.Setenv("MOW_VALUE", "a,b,c") c.Strings(StringsArg{Name: "ARG", EnvVar: "MOW_VALUE", SetByUser: s}) }, args: []string{"test"}, expected: false, }, { desc: "Strings Arg, set by user", config: func(c *Cli, s *bool) { c.Spec = "[ARG...]" c.Strings(StringsArg{Name: "ARG", SetByUser: s}) }, args: []string{"test", "aaa", "ccc"}, expected: true, }, } for _, cas := range cases { t.Run(cas.desc, func(t *testing.T) { t.Log(cas.desc) setByUser := false app := App("test", "") cas.config(app, &setByUser) called := false app.Action = func() { called = true } require.NoError(t, app.Run(cas.args)) require.True(t, called, "action should have been called") require.Equal(t, cas.expected, setByUser) }) } } func TestOptSetByEnv(t *testing.T) { cases := []struct { desc string config func(*Cli) interface{} args []string expected interface{} }{ // OPTS // String { desc: "String Opt, empty env var", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "") return c.String(StringOpt{Name: "f", Value: "default", EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: "default", }, { desc: "String Opt, env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "env") return c.String(StringOpt{Name: "f", Value: "default", EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: "env", }, { desc: "String Opt, env set, set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "env") return c.String(StringOpt{Name: "f", Value: "default", EnvVar: "MOW_VALUE"}) }, args: []string{"test", "-f=user"}, expected: "user", }, // Bool { desc: "Bool Opt, empty env var", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "") return c.Bool(BoolOpt{Name: "f", Value: true, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Opt, env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "true") return c.Bool(BoolOpt{Name: "f", Value: false, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Opt, multi env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE1", "xxx") os.Setenv("MOW_VALUE2", "true") return c.Bool(BoolOpt{Name: "f", Value: false, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Opt, env set bad value, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "xxx") return c.Bool(BoolOpt{Name: "f", Value: true, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Opt, env set, set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "false") return c.Bool(BoolOpt{Name: "f", Value: false, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "-f"}, expected: true, }, // Int { desc: "Int Opt, empty env var", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "") return c.Int(IntOpt{Name: "f", Value: 42, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Opt, env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "42") return c.Int(IntOpt{Name: "f", Value: 17, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Opt, multi env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE1", "xxx") os.Setenv("MOW_VALUE2", "42") return c.Int(IntOpt{Name: "f", Value: 17, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Opt, env set bad value, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "xxx") return c.Int(IntOpt{Name: "f", Value: 42, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Opt, env set, set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "42") return c.Int(IntOpt{Name: "f", Value: 17, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "-f=72"}, expected: 72, }, // Strings { desc: "Strings Opt, empty env var", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "") return c.Strings(StringsOpt{Name: "f", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []string{"oh", "ai"}, }, { desc: "Strings Opt, env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "do, re, mi") return c.Strings(StringsOpt{Name: "f", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []string{"do", "re", "mi"}, }, { desc: "Strings Opt, multi env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE1", "") os.Setenv("MOW_VALUE2", "do, re, mi") return c.Strings(StringsOpt{Name: "f", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: []string{"do", "re", "mi"}, }, { desc: "Strings Opt, env set, set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "do, re") c.Spec = "-f..." return c.Strings(StringsOpt{Name: "f", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "-f=mi", "-f=fa"}, expected: []string{"mi", "fa"}, }, // Ints { desc: "Ints Opt, empty env var", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "") return c.Ints(IntsOpt{Name: "f", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []int{1, 2}, }, { desc: "Ints Opt, env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "11, 13, 17") return c.Ints(IntsOpt{Name: "f", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []int{11, 13, 17}, }, { desc: "Ints Opt, multi env set, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE1", "10, 20, xxx") os.Setenv("MOW_VALUE2", "11, 13, 17") return c.Ints(IntsOpt{Name: "f", Value: []int{1, 2}, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: []int{11, 13, 17}, }, { desc: "Ints Opt, env set bad value, not set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "xxx") return c.Ints(IntsOpt{Name: "f", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []int(nil), //TODO: this is bad and you should feel bad }, { desc: "Ints Opt, env set, set by user", config: func(c *Cli) interface{} { os.Setenv("MOW_VALUE", "42") c.Spec = "-f..." return c.Ints(IntsOpt{Name: "f", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "-f=5", "-f=7"}, expected: []int{5, 7}, }, } for _, cas := range cases { t.Run(cas.desc, func(t *testing.T) { t.Log(cas.desc) app := App("test", "") pointer := cas.config(app) called := false app.Action = func() { called = true } require.NoError(t, app.Run(cas.args)) typ := reflect.TypeOf(pointer) if typ.Kind() != reflect.Ptr { t.Fatalf("config func did not return a pointer") } actualValue := reflect.ValueOf(pointer).Elem().Interface() require.True(t, called, "action should have been called") require.Equal(t, cas.expected, actualValue) }) } } func TestArgSetByEnv(t *testing.T) { cases := []struct { desc string config func(*Cli) interface{} args []string expected interface{} }{ // ARGs // String { desc: "String Arg, empty env var", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "") return c.String(StringArg{Name: "ARG", Value: "default", EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: "default", }, { desc: "String Arg, env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "env") return c.String(StringArg{Name: "ARG", Value: "default", EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: "env", }, { desc: "String Arg, env set, set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "env") return c.String(StringArg{Name: "ARG", Value: "default", EnvVar: "MOW_VALUE"}) }, args: []string{"test", "user"}, expected: "user", }, // Bool { desc: "Bool Arg, empty env var", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "") return c.Bool(BoolArg{Name: "ARG", Value: true, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Arg, env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "true") return c.Bool(BoolArg{Name: "ARG", Value: false, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Arg, multi env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE1", "xxx") os.Setenv("MOW_VALUE2", "true") return c.Bool(BoolArg{Name: "ARG", Value: false, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Arg, env set bad value, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "xxx") return c.Bool(BoolArg{Name: "ARG", Value: true, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: true, }, { desc: "Bool Arg, env set, set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "false") return c.Bool(BoolArg{Name: "ARG", Value: false, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "TRUE"}, expected: true, }, // Int { desc: "Int Arg, empty env var", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "") return c.Int(IntArg{Name: "ARG", Value: 42, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Arg, env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "42") return c.Int(IntArg{Name: "ARG", Value: 17, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Arg, multi env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE1", "xxx") os.Setenv("MOW_VALUE2", "42") return c.Int(IntArg{Name: "ARG", Value: 17, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Arg, env set bad value, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "xxx") return c.Int(IntArg{Name: "ARG", Value: 42, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: 42, }, { desc: "Int Arg, env set, set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "42") return c.Int(IntArg{Name: "ARG", Value: 17, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "72"}, expected: 72, }, // Strings { desc: "Strings Arg, empty env var", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "") return c.Strings(StringsArg{Name: "ARG", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []string{"oh", "ai"}, }, { desc: "Strings Arg, env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "do, re, mi") return c.Strings(StringsArg{Name: "ARG", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []string{"do", "re", "mi"}, }, { desc: "Strings Arg, multi env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE1", "") os.Setenv("MOW_VALUE2", "do, re, mi") return c.Strings(StringsArg{Name: "ARG", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: []string{"do", "re", "mi"}, }, { desc: "Strings Arg, env set, set by user", config: func(c *Cli) interface{} { c.Spec = "ARG..." os.Setenv("MOW_VALUE", "do, re") return c.Strings(StringsArg{Name: "ARG", Value: []string{"oh", "ai"}, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "mi", "fa"}, expected: []string{"mi", "fa"}, }, // Ints { desc: "Ints Arg, empty env var", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "") return c.Ints(IntsArg{Name: "ARG", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []int{1, 2}, }, { desc: "Ints Arg, env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "11, 13, 17") return c.Ints(IntsArg{Name: "ARG", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []int{11, 13, 17}, }, { desc: "Ints Arg, multi env set, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE1", "10, 20, xxx") os.Setenv("MOW_VALUE2", "11, 13, 17") return c.Ints(IntsArg{Name: "ARG", Value: []int{1, 2}, EnvVar: "MOW_VALUE1 MOW_VALUE2"}) }, args: []string{"test"}, expected: []int{11, 13, 17}, }, { desc: "Ints Arg, env set bad value, not set by user", config: func(c *Cli) interface{} { c.Spec = "[ARG]" os.Setenv("MOW_VALUE", "xxx") return c.Ints(IntsArg{Name: "ARG", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test"}, expected: []int(nil), //TODO: this is bad and you should feel bad }, { desc: "Ints Arg, env set, set by user", config: func(c *Cli) interface{} { c.Spec = "ARG..." os.Setenv("MOW_VALUE", "42") return c.Ints(IntsArg{Name: "ARG", Value: []int{1, 2}, EnvVar: "MOW_VALUE"}) }, args: []string{"test", "5", "7"}, expected: []int{5, 7}, }, } for _, cas := range cases { t.Run(cas.desc, func(t *testing.T) { t.Log(cas.desc) app := App("test", "") app.ErrorHandling = flag.ContinueOnError pointer := cas.config(app) called := false app.Action = func() { called = true } require.NoError(t, app.Run(cas.args)) typ := reflect.TypeOf(pointer) if typ.Kind() != reflect.Ptr { t.Fatalf("config func did not return a pointer") } actualValue := reflect.ValueOf(pointer).Elem().Interface() require.True(t, called, "action should have been called") require.Equal(t, cas.expected, actualValue) }) } } func TestCommandAction(t *testing.T) { called := false app := App("app", "") app.Command("a", "", ActionCommand(func() { called = true })) require.NoError(t, app.Run([]string{"app", "a"})) require.True(t, called, "commandAction should be called") } func TestCommandAliases(t *testing.T) { defer suppressOutput()() cases := []struct { args []string errorExpected bool }{ { args: []string{"say", "hello"}, errorExpected: false, }, { args: []string{"say", "hi"}, errorExpected: false, }, { args: []string{"say", "hello hi"}, errorExpected: true, }, { args: []string{"say", "hello", "hi"}, errorExpected: true, }, } for _, cas := range cases { t.Run(fmt.Sprintf("%+v", cas.args), func(t *testing.T) { app := App("say", "") app.ErrorHandling = flag.ContinueOnError called := false app.Command("hello hi", "", func(cmd *Cmd) { cmd.Action = func() { called = true } }) err := app.Run(cas.args) if cas.errorExpected { require.Error(t, err, "Run() should have returned with an error") require.False(t, called, "action should not have been called") } else { require.NoError(t, err, "Run() should have returned without an error") require.True(t, called, "action should have been called") } }) } } func TestSubcommandAliases(t *testing.T) { cases := []struct { args []string }{ { args: []string{"app", "foo", "bar", "baz"}, }, { args: []string{"app", "foo", "bar", "z"}, }, { args: []string{"app", "foo", "b", "baz"}, }, { args: []string{"app", "f", "bar", "baz"}, }, { args: []string{"app", "f", "b", "baz"}, }, { args: []string{"app", "f", "b", "z"}, }, { args: []string{"app", "foo", "b", "z"}, }, { args: []string{"app", "f", "bar", "z"}, }, } for _, cas := range cases { t.Run(fmt.Sprintf("%+v", cas.args), func(t *testing.T) { app := App("app", "") app.ErrorHandling = flag.ContinueOnError called := false app.Command("foo f", "", func(cmd *Cmd) { cmd.Command("bar b", "", func(cmd *Cmd) { cmd.Command("baz z", "", func(cmd *Cmd) { cmd.Action = func() { called = true } }) }) }) err := app.Run(cas.args) require.NoError(t, err, "Run() should have returned without an error") require.True(t, called, "action should have been called") }) } } func TestBeforeAndAfterFlowOrder(t *testing.T) { counter := 0 app := App("app", "") app.Before = callChecker(t, 0, &counter) app.Command("c", "", func(c *Cmd) { c.Before = callChecker(t, 1, &counter) c.Command("cc", "", func(cc *Cmd) { cc.Before = callChecker(t, 2, &counter) cc.Action = callChecker(t, 3, &counter) cc.After = callChecker(t, 4, &counter) }) c.After = callChecker(t, 5, &counter) }) app.After = callChecker(t, 6, &counter) require.NoError(t, app.Run([]string{"app", "c", "cc"})) require.Equal(t, 7, counter) } func TestBeforeAndAfterFlowOrderWhenOneBeforePanics(t *testing.T) { defer func() { r := recover() require.Equal(t, 42, r) }() counter := 0 app := App("app", "") app.Before = callChecker(t, 0, &counter) app.Command("c", "", func(c *Cmd) { c.Before = callChecker(t, 1, &counter) c.Command("cc", "", func(cc *Cmd) { cc.Before = callCheckerAndPanic(t, 42, 2, &counter) cc.Action = func() { t.Fatalf("should not have been called") } cc.After = func() { t.Fatalf("should not have been called") } }) c.After = callChecker(t, 3, &counter) }) app.After = callChecker(t, 4, &counter) require.NoError(t, app.Run([]string{"app", "c", "cc"})) require.Equal(t, 5, counter) } func TestBeforeAndAfterFlowOrderWhenOneAfterPanics(t *testing.T) { defer func() { e := recover() require.Equal(t, 42, e) }() counter := 0 app := App("app", "") app.Before = callChecker(t, 0, &counter) app.Command("c", "", func(c *Cmd) { c.Before = callChecker(t, 1, &counter) c.Command("cc", "", func(cc *Cmd) { cc.Before = callChecker(t, 2, &counter) cc.Action = callChecker(t, 3, &counter) cc.After = callCheckerAndPanic(t, 42, 4, &counter) }) c.After = callChecker(t, 5, &counter) }) app.After = callChecker(t, 6, &counter) require.NoError(t, app.Run([]string{"app", "c", "cc"})) require.Equal(t, 7, counter) } func TestBeforeAndAfterFlowOrderWhenMultipleAftersPanic(t *testing.T) { defer func() { e := recover() require.Equal(t, 666, e) }() counter := 0 app := App("app", "") app.Before = callChecker(t, 0, &counter) app.Command("c", "", func(c *Cmd) { c.Before = callChecker(t, 1, &counter) c.Command("cc", "", func(cc *Cmd) { cc.Before = callChecker(t, 2, &counter) cc.Action = callChecker(t, 3, &counter) cc.After = callCheckerAndPanic(t, 42, 4, &counter) }) c.After = callChecker(t, 5, &counter) }) app.After = callCheckerAndPanic(t, 666, 6, &counter) require.NoError(t, app.Run([]string{"app", "c", "cc"})) require.Equal(t, 7, counter) } func exitShouldBeCalledWith(t *testing.T, wantedExitCode int, called *bool) func() { oldExiter := exiter exiter = func(code int) { require.Equal(t, wantedExitCode, code, "unwanted exit code") *called = true } return func() { exiter = oldExiter } } func exitShouldNotCalled(t *testing.T) func() { oldExiter := exiter exiter = func(code int) { t.Errorf("exit should not have been called") } return func() { exiter = oldExiter } } func suppressOutput() func() { return captureAndRestoreOutput(nil, nil) } func captureAndRestoreOutput(out, err *string) func() { oldStdOut := stdOut oldStdErr := stdErr if out == nil { stdOut = ioutil.Discard } else { stdOut = trapWriter(out) } if err == nil { stdErr = ioutil.Discard } else { stdErr = trapWriter(err) } return func() { stdOut = oldStdOut stdErr = oldStdErr } } func trapWriter(writeTo *string) *writerTrap { return &writerTrap{ buffer: bytes.NewBuffer(nil), writeTo: writeTo, } } type writerTrap struct { buffer *bytes.Buffer writeTo *string } func (w *writerTrap) Write(p []byte) (n int, err error) { n, err = w.buffer.Write(p) if err == nil { *(w.writeTo) = w.buffer.String() } return } func callChecker(t *testing.T, wanted int, counter *int) func() { return func() { t.Logf("checker: wanted: %d, got %d", wanted, *counter) require.Equal(t, wanted, *counter) *counter++ } } func callCheckerAndPanic(t *testing.T, panicValue interface{}, wanted int, counter *int) func() { return func() { t.Logf("checker: wanted: %d, got %d", wanted, *counter) require.Equal(t, wanted, *counter) *counter++ panic(panicValue) } } mow.cli-1.1.0/commands.go000066400000000000000000000525001346511200500152100ustar00rootroot00000000000000package cli import ( "flag" "fmt" "io" "strings" "text/tabwriter" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/flow" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/lexer" "github.com/jawher/mow.cli/internal/parser" "github.com/jawher/mow.cli/internal/values" ) /* Cmd represents a command (or sub command) in a CLI application. It should be constructed by calling Command() on an app to create a top level command or by calling Command() on another command to create a sub command */ type Cmd struct { // The code to execute when this command is matched Action func() // The code to execute before this command or any of its children is matched Before func() // The code to execute after this command or any of its children is matched After func() // The command options and arguments Spec string // The command long description to be shown when help is requested LongDesc string // The command error handling strategy ErrorHandling flag.ErrorHandling init CmdInitializer name string aliases []string desc string commands []*Cmd options []*container.Container optionsIdx map[string]*container.Container args []*container.Container argsIdx map[string]*container.Container parents []string fsm *fsm.State } /* BoolParam represents a Bool option or argument */ type BoolParam interface { value(into *bool) (flag.Value, *bool) } /* StringParam represents a String option or argument */ type StringParam interface { value(into *string) (flag.Value, *string) } /* IntParam represents an Int option or argument */ type IntParam interface { value(into *int) (flag.Value, *int) } /* Float64Param represents an Float64 option or argument */ type Float64Param interface { value(into *float64) (flag.Value, *float64) } /* StringsParam represents a string slice option or argument */ type StringsParam interface { value(into *[]string) (flag.Value, *[]string) } /* IntsParam represents an float64 slice option or argument */ type IntsParam interface { value(into *[]int) (flag.Value, *[]int) } /* Floats64Param represents an float64 slice option or argument */ type Floats64Param interface { value(into *[]float64) (flag.Value, *[]float64) } /* VarParam represents an custom option or argument where the type and format are controlled by the developer */ type VarParam interface { value() flag.Value } /* CmdInitializer is a function that configures a command by adding options, arguments, a spec, sub commands and the code to execute when the command is called */ type CmdInitializer func(*Cmd) /* Command adds a new (sub) command to c where name is the command name (what you type in the console), description is what would be shown in the help messages, e.g.: Usage: git [OPTIONS] COMMAND [arg...] Commands: $name $desc the last argument, init, is a function that will be called by mow.cli to further configure the created (sub) command, e.g. to add options, arguments and the code to execute */ func (c *Cmd) Command(name, desc string, init CmdInitializer) { aliases := strings.Fields(name) c.commands = append(c.commands, &Cmd{ ErrorHandling: c.ErrorHandling, name: aliases[0], aliases: aliases, desc: desc, init: init, commands: []*Cmd{}, options: []*container.Container{}, optionsIdx: map[string]*container.Container{}, args: []*container.Container{}, argsIdx: map[string]*container.Container{}, }) } /* Bool can be used to add a bool option or argument to a command. It accepts either a BoolOpt or a BoolArg struct. The result should be stored in a variable (a pointer to a bool) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Bool(p BoolParam) *bool { value, into := p.value(nil) switch x := p.(type) { case BoolOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case BoolArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* BoolPtr can be used to add a bool option or argument to a command. It accepts either a pointer to a bool var and a BoolOpt or a BoolArg struct. The into parameter points to a variable (a pointer to a bool) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) BoolPtr(into *bool, p BoolParam) { value, _ := p.value(into) switch x := p.(type) { case BoolOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case BoolArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* String can be used to add a string option or argument to a command. It accepts either a StringOpt or a StringArg struct. The result should be stored in a variable (a pointer to a string) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) String(p StringParam) *string { value, into := p.value(nil) switch x := p.(type) { case StringOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case StringArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* StringPtr can be used to add a string option or argument to a command. It accepts either a pointer to a string var and a StringOpt or a StringArg struct. The into parameter points to a variable (a pointer to a string) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringPtr(into *string, p StringParam) { value, _ := p.value(into) switch x := p.(type) { case StringOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case StringArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* Int can be used to add an int option or argument to a command. It accepts either a IntOpt or a IntArg struct. The result should be stored in a variable (a pointer to an int) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Int(p IntParam) *int { value, into := p.value(nil) switch x := p.(type) { case IntOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case IntArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* IntPtr can be used to add a int option or argument to a command. It accepts either a pointer to a int var and a IntOpt or a IntArg struct. The into parameter points to a variable (a pointer to a int) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntPtr(into *int, p IntParam) { value, _ := p.value(into) switch x := p.(type) { case IntOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case IntArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* Float64 can be used to add a float64 option or argument to a command. It accepts either a Float64Opt or a Float64Arg struct. The result should be stored in a variable (a pointer to a float64) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Float64(p Float64Param) *float64 { value, into := p.value(nil) switch x := p.(type) { case Float64Opt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case Float64Arg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* Float64Ptr can be used to add a float64 option or argument to a command. It accepts either a pointer to a float64 var and a Float64Opt or a Float64Arg struct. The into parameter points to a variable (a pointer to a float64) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Float64Ptr(into *float64, p Float64Param) { value, _ := p.value(into) switch x := p.(type) { case Float64Opt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case Float64Arg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* Strings can be used to add a string slice option or argument to a command. It accepts either a StringsOpt or a StringsArg struct. The result should be stored in a variable (a pointer to a string slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Strings(p StringsParam) *[]string { value, into := p.value(nil) switch x := p.(type) { case StringsOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case StringsArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* StringsPtr can be used to add a string slice option or argument to a command. It accepts either a pointer to a string slice var and a StringsOpt or a StringsArg struct. The into parameter points to a variable (a pointer to a string slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringsPtr(into *[]string, p StringsParam) { value, _ := p.value(into) switch x := p.(type) { case StringsOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case StringsArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* Ints can be used to add an int slice option or argument to a command. It accepts either a IntsOpt or a IntsArg struct. The result should be stored in a variable (a pointer to an int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Ints(p IntsParam) *[]int { value, into := p.value(nil) switch x := p.(type) { case IntsOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case IntsArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* IntsPtr can be used to add a int slice option or argument to a command. It accepts either a pointer to a int slice var and a IntsOpt or a IntsArg struct. The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntsPtr(into *[]int, p IntsParam) { value, _ := p.value(into) switch x := p.(type) { case IntsOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case IntsArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* Floats64 can be used to add an float64 slice option or argument to a command. It accepts either a Floats64Opt or a Floats64Arg struct. The result should be stored in a variable (a pointer to an float64 slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Floats64(p Floats64Param) *[]float64 { value, into := p.value(nil) switch x := p.(type) { case Floats64Opt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case Floats64Arg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } return into } /* Floats64Ptr can be used to add a float64 slice option or argument to a command. It accepts either a pointer to a float64 slice var and a Floats64Opt or a Floats64Arg struct. The into parameter points to a variable (a pointer to a float64 slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Floats64Ptr(into *[]float64, p Floats64Param) { value, _ := p.value(into) switch x := p.(type) { case Floats64Opt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) case Floats64Arg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: value, ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } /* Var can be used to add a custom option or argument to a command. It accepts either a VarOpt or a VarArg struct. As opposed to the other built-in types, this function does not return a pointer the the value. Instead, the VarOpt or VarOptArg structs hold the said value. */ func (c *Cmd) Var(p VarParam) { switch x := p.(type) { case VarOpt: c.mkOpt(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: p.value(), ValueSetByUser: x.SetByUser}) case VarArg: c.mkArg(container.Container{Name: x.Name, Desc: x.Desc, EnvVar: x.EnvVar, HideValue: x.HideValue, Value: p.value(), ValueSetByUser: x.SetByUser}) default: panic(fmt.Sprintf("Unhandled param %v", p)) } } func (c *Cmd) doInit() error { if c.init != nil { c.init(c) } parents := append(c.parents, c.name) for _, sub := range c.commands { sub.parents = parents } if len(c.Spec) == 0 { if len(c.options) > 0 { c.Spec = "[OPTIONS] " } for _, arg := range c.args { c.Spec += arg.Name + " " } } tokens, err := lexer.Tokenize(c.Spec) if err != nil { return err } params := parser.Params{ Spec: c.Spec, Options: c.options, OptionsIdx: c.optionsIdx, Args: c.args, ArgsIdx: c.argsIdx, } s, err := parser.Parse(tokens, params) if err != nil { return err } c.fsm = s return nil } func (c *Cmd) onError(err error) { if err == errHelpRequested || err == errVersionRequested { if c.ErrorHandling == flag.ExitOnError { exiter(0) } return } switch c.ErrorHandling { case flag.ExitOnError: exiter(2) case flag.PanicOnError: panic(err) } } /* PrintHelp prints the command's help message. In most cases the library users won't need to call this method, unless a more complex validation is needed */ func (c *Cmd) PrintHelp() { c.printHelp(false) } /* PrintLongHelp prints the command's help message using the command long description if specified. In most cases the library users won't need to call this method, unless a more complex validation is needed */ func (c *Cmd) PrintLongHelp() { c.printHelp(true) } func (c *Cmd) printHelp(longDesc bool) { full := append(c.parents, c.name) path := strings.Join(full, " ") fmt.Fprintf(stdErr, "\nUsage: %s", path) spec := strings.TrimSpace(c.Spec) if len(spec) > 0 { fmt.Fprintf(stdErr, " %s", spec) } if len(c.commands) > 0 { fmt.Fprint(stdErr, " COMMAND [arg...]") } fmt.Fprint(stdErr, "\n\n") desc := c.desc if longDesc && len(c.LongDesc) > 0 { desc = c.LongDesc } if len(desc) > 0 { fmt.Fprintf(stdErr, "%s\n", desc) } w := tabwriter.NewWriter(stdErr, 15, 1, 3, ' ', 0) if len(c.args) > 0 { fmt.Fprint(w, "\t\nArguments:\t\n") for _, arg := range c.args { var ( env = formatEnvVarsForHelp(arg.EnvVar) value = formatValueForHelp(arg.HideValue, arg.Value) ) printTabbedRow(w, arg.Name, joinStrings(arg.Desc, env, value)) } } if len(c.options) > 0 { fmt.Fprint(w, "\t\nOptions:\t\n") for _, opt := range c.options { var ( optNames = formatOptNamesForHelp(opt) env = formatEnvVarsForHelp(opt.EnvVar) value = formatValueForHelp(opt.HideValue, opt.Value) ) printTabbedRow(w, optNames, joinStrings(opt.Desc, env, value)) } } if len(c.commands) > 0 { fmt.Fprint(w, "\t\nCommands:\t\n") for _, c := range c.commands { fmt.Fprintf(w, " %s\t%s\n", strings.Join(c.aliases, ", "), c.desc) } } if len(c.commands) > 0 { fmt.Fprintf(w, "\t\nRun '%s COMMAND --help' for more information on a command.\n", path) } w.Flush() } func formatOptNamesForHelp(o *container.Container) string { short, long := "", "" for _, n := range o.Names { if len(n) == 2 && short == "" { short = n } if len(n) > 2 && long == "" { long = n } } switch { case short != "" && long != "": return fmt.Sprintf("%s, %s", short, long) case short != "": return short case long != "": // 2 spaces instead of the short option (-x), one space for the comma (,) and one space for the after comma blank return fmt.Sprintf(" %s", long) default: return "" } } func formatValueForHelp(hide bool, v flag.Value) string { if hide { return "" } if dv, ok := v.(values.DefaultValued); ok { if dv.IsDefault() { return "" } } return fmt.Sprintf("(default %s)", v.String()) } func formatEnvVarsForHelp(envVars string) string { if strings.TrimSpace(envVars) == "" { return "" } vars := strings.Fields(envVars) res := "(env" sep := " " for i, v := range vars { if i > 0 { sep = ", " } res += fmt.Sprintf("%s$%s", sep, v) } res += ")" return res } func (c *Cmd) parse(args []string, entry, inFlow, outFlow *flow.Step) error { if c.helpRequested(args) { c.PrintLongHelp() c.onError(errHelpRequested) return nil } nargsLen := c.getOptsAndArgs(args) if err := c.fsm.Parse(args[:nargsLen]); err != nil { fmt.Fprintf(stdErr, "Error: %s\n", err.Error()) c.PrintHelp() c.onError(err) return err } newInFlow := &flow.Step{ Do: c.Before, Error: outFlow, Desc: fmt.Sprintf("%s.Before", c.name), Exiter: exiter, } inFlow.Success = newInFlow newOutFlow := &flow.Step{ Do: c.After, Success: outFlow, Error: outFlow, Desc: fmt.Sprintf("%s.After", c.name), Exiter: exiter, } args = args[nargsLen:] if len(args) == 0 { if c.Action != nil { newInFlow.Success = &flow.Step{ Do: c.Action, Success: newOutFlow, Error: newOutFlow, Desc: fmt.Sprintf("%s.Action", c.name), Exiter: exiter, } entry.Run(nil) return nil } c.PrintHelp() c.onError(nil) return nil } arg := args[0] for _, sub := range c.commands { if sub.isAlias(arg) { if err := sub.doInit(); err != nil { panic(err) } return sub.parse(args[1:], entry, newInFlow, newOutFlow) } } var err error switch { case strings.HasPrefix(arg, "-"): err = fmt.Errorf("Error: illegal option %s", arg) fmt.Fprintln(stdErr, err.Error()) default: err = fmt.Errorf("Error: illegal input %s", arg) fmt.Fprintln(stdErr, err.Error()) } c.PrintHelp() c.onError(err) return err } func (c *Cmd) helpRequested(args []string) bool { return c.isFlagSet(args, []string{"-h", "--help"}) } func (c *Cmd) isFlagSet(args []string, searchArgs []string) bool { if len(args) == 0 { return false } arg := args[0] for _, searchArg := range searchArgs { if arg == searchArg { return true } } return false } func (c *Cmd) getOptsAndArgs(args []string) int { consumed := 0 for _, arg := range args { for _, sub := range c.commands { if sub.isAlias(arg) { return consumed } } consumed++ } return consumed } func (c *Cmd) isAlias(arg string) bool { for _, alias := range c.aliases { if arg == alias { return true } } return false } func joinStrings(parts ...string) string { res := "" for _, part := range parts { s := strings.TrimSpace(part) if s == "" { continue } if res != "" { res += " " } res += part } return res } func printTabbedRow(w io.Writer, s1 string, s2 string) { lines := strings.Split(s2, "\n") fmt.Fprintf(w, " %s\t%s\n", s1, strings.TrimSpace(lines[0])) if len(lines) == 1 { return } for _, line := range lines[1:] { fmt.Fprintf(w, " %s\t%s\n", "", strings.TrimSpace(line)) } } mow.cli-1.1.0/commands_test.go000066400000000000000000000735761346511200500162670ustar00rootroot00000000000000package cli import ( "flag" "os" "strings" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "testing" "fmt" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/flow" ) func okCmd(t *testing.T, spec string, init CmdInitializer, args []string) { defer suppressOutput()() cmd := &Cmd{ name: "test", optionsIdx: map[string]*container.Container{}, argsIdx: map[string]*container.Container{}, } cmd.Spec = spec cmd.ErrorHandling = flag.ContinueOnError init(cmd) err := cmd.doInit() require.Nil(t, err, "should parse") t.Logf("testing spec %q with args: %#v", spec, args) inFlow := &flow.Step{} err = cmd.parse(args, inFlow, inFlow, &flow.Step{}) require.Nil(t, err, "cmd parse should't fail") } func failCmd(t *testing.T, spec string, init CmdInitializer, args []string) { defer suppressOutput()() cmd := &Cmd{ name: "test", optionsIdx: map[string]*container.Container{}, argsIdx: map[string]*container.Container{}, } cmd.Spec = spec cmd.ErrorHandling = flag.ContinueOnError init(cmd) err := cmd.doInit() require.NoError(t, err, "should parse") t.Logf("testing spec %q with args: %#v", spec, args) inFlow := &flow.Step{} err = cmd.parse(args, inFlow, inFlow, &flow.Step{}) require.Error(t, err, "cmd parse should have failed") } func badSpec(t *testing.T, spec string, init CmdInitializer) { cmd := &Cmd{ name: "test", optionsIdx: map[string]*container.Container{}, argsIdx: map[string]*container.Container{}, } cmd.Spec = spec cmd.ErrorHandling = flag.ContinueOnError init(cmd) t.Logf("testing bad spec %s", spec) err := cmd.doInit() require.NotNil(t, err, "Bad spec %s should have failed to parse", spec) t.Logf("Bad spec %s did fail to parse with error: %v", spec, err) } func TestSpecBoolOpt(t *testing.T) { var f *bool init := func(c *Cmd) { f = c.BoolOpt("f force", false, "") } spec := "-f" okCases := []struct { args []string expected bool }{ {args: []string{"-f"}, expected: true}, {args: []string{"--force"}, expected: true}, {args: []string{"-f=true"}, expected: true}, {args: []string{"--force=true"}, expected: true}, {args: []string{"--force=false"}, expected: false}, } for _, cas := range okCases { t.Run(fmt.Sprintf("okCase: %+v", cas.args), func(t *testing.T) { okCmd(t, spec, init, cas.args) require.Equal(t, cas.expected, *f) }) } badCases := [][]string{ {}, {"-g"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "true"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %+v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestDefaultSpec(t *testing.T) { var ( a *bool b *string c *string ) type call struct { args []string a bool b, c string } cases := []struct { init func(cmd *Cmd) calls []call }{ { func(cmd *Cmd) { a = cmd.BoolOpt("a", false, "") b = cmd.StringOpt("b", "", "") c = cmd.StringArg("C", "", "") }, []call{ {[]string{"X"}, false, "", "X"}, {[]string{"-a", "X"}, true, "", "X"}, {[]string{"-b=Z", "X"}, false, "Z", "X"}, {[]string{"-b=Z", "-a", "X"}, true, "Z", "X"}, {[]string{"-a", "-b=Z", "X"}, true, "Z", "X"}, }, }, } for _, cas := range cases { for _, cl := range cas.calls { t.Run(fmt.Sprintf("%+v", cl.args), func(t *testing.T) { okCmd(t, "", cas.init, cl.args) require.Equal(t, cl.a, *a) require.Equal(t, cl.b, *b) require.Equal(t, cl.c, *c) }) } } } func TestSpecOptFolding(t *testing.T) { var a, b, c *bool var d *string init := func(cmd *Cmd) { a = cmd.BoolOpt("a", false, "") b = cmd.BoolOpt("b", false, "") c = cmd.BoolOpt("c", false, "") d = cmd.StringOpt("d", "", "") } cases := []struct { spec string args []string a, b, c bool d string }{ { "[-abcd]", []string{}, false, false, false, "", }, { "[-abcd]", []string{"-ab"}, true, true, false, "", }, { "[-abcd]", []string{"-ba"}, true, true, false, "", }, { "[-abcd]", []string{"-ad", "TEST"}, true, false, false, "TEST", }, { "[-abcd]", []string{"-adTEST"}, true, false, false, "TEST", }, { "[-abcd]", []string{"-abd", "TEST"}, true, true, false, "TEST", }, { "[-abcd]", []string{"-abdTEST"}, true, true, false, "TEST", }, { "[-abcd]", []string{"-abcd", "TEST"}, true, true, true, "TEST", }, { "[-abcd]", []string{"-bcd", "TEST"}, false, true, true, "TEST", }, { "[-abcd]", []string{"-cbd", "TEST"}, false, true, true, "TEST", }, { "[-abcd]", []string{"-ac"}, true, false, true, "", }, { "[-abcd]", []string{"-ca"}, true, false, true, "", }, { "[-abcd]", []string{"-cab"}, true, true, true, "", }, } for _, cas := range cases { t.Run(fmt.Sprintf("%s :: %+v", cas.spec, cas.args), func(t *testing.T) { okCmd(t, cas.spec, init, cas.args) require.Equal(t, cas.a, *a) require.Equal(t, cas.b, *b) require.Equal(t, cas.c, *c) require.Equal(t, cas.d, *d) }) } } func TestSpecStrOpt(t *testing.T) { var f *string init := func(c *Cmd) { f = c.StringOpt("f", "", "") } spec := "-f" cases := [][]string{ {"-fValue"}, {"-f", "Value"}, {"-f=Value"}, } for _, args := range cases { okCmd(t, spec, init, args) require.Equal(t, "Value", *f) } badCases := [][]string{ {}, {"-g"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "xxx", "yyy"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("%+v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecIntOpt(t *testing.T) { var f *int init := func(c *Cmd) { f = c.IntOpt("f", -1, "") } spec := "-f" cases := [][]string{ {"-f42"}, {"-f", "42"}, {"-f=42"}, } for _, args := range cases { okCmd(t, spec, init, args) require.Equal(t, 42, *f) } badCases := [][]string{ {}, {"-f", "x"}, {"-g"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("%+v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecStrsOpt(t *testing.T) { var f *[]string init := func(c *Cmd) { f = c.StringsOpt("f", nil, "") } spec := "-f..." cases := [][]string{ {"-fA"}, {"-f", "A"}, {"-f=A"}, } for _, args := range cases { okCmd(t, spec, init, args) require.Equal(t, []string{"A"}, *f) } cases = [][]string{ {"-fA", "-f", "B"}, {"-f", "A", "-f", "B"}, {"-f=A", "-fB"}, } for _, args := range cases { t.Run(fmt.Sprintf("okCase: %#v", args), func(t *testing.T) { okCmd(t, spec, init, args) require.Equal(t, []string{"A", "B"}, *f) }) } badCases := [][]string{ {}, {"-g"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "xxx", "yyy"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecIntsOpt(t *testing.T) { var f *[]int init := func(c *Cmd) { f = c.IntsOpt("f", nil, "") } spec := "-f..." cases := [][]string{ {"-f1"}, {"-f", "1"}, {"-f=1"}, } for _, args := range cases { okCmd(t, spec, init, args) require.Equal(t, []int{1}, *f) } cases = [][]string{ {"-f1", "-f", "2"}, {"-f", "1", "-f", "2"}, {"-f=1", "-f2"}, } for _, args := range cases { t.Run(fmt.Sprintf("okCase: %#v", args), func(t *testing.T) { okCmd(t, spec, init, args) require.Equal(t, []int{1, 2}, *f) }) } badCases := [][]string{ {}, {"-f", "b"}, {"-f", "3", "-f", "c"}, {"-g"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecOptionalOpt(t *testing.T) { var f *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") } spec := "[-f]" //TODO: table driven okCmd(t, "[-f]", init, []string{"-f"}) require.True(t, *f) okCmd(t, spec, init, []string{}) require.False(t, *f) badCases := [][]string{ {"-g"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecArg(t *testing.T) { var s *string init := func(c *Cmd) { s = c.StringArg("ARG", "", "") } spec := "ARG" okCmd(t, spec, init, []string{"value"}) require.Equal(t, "value", *s) badCases := [][]string{ {}, {"-g"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecOptionalArg(t *testing.T) { var s *string init := func(c *Cmd) { s = c.StringArg("ARG", "", "") } spec := "[ARG]" okCmd(t, spec, init, []string{"value"}) require.Equal(t, "value", *s) okCmd(t, spec, init, []string{}) require.Equal(t, "", *s) badCases := [][]string{ {"-g"}, {"-g", "-f"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecOptionChoice(t *testing.T) { var f, g *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") } spec := "-f|-g" //TODO: table driven okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) badCases := [][]string{ {}, {"-f", "-g"}, {"-f", "-s"}, {"-g", "-f"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecOptional2OptionChoice(t *testing.T) { var f, g *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") } spec := "[-f|-g]" //TODO: okCmd(t, spec, init, []string{}) require.False(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) badCases := [][]string{ {"-s"}, {"-f", "-g"}, {"-g", "-f"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecRepeatable2OptionChoice(t *testing.T) { var f, g *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") } spec := "(-f|-g)..." //TODO: okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) okCmd(t, spec, init, []string{"-f", "-g"}) require.True(t, *f) require.True(t, *g) okCmd(t, spec, init, []string{"-g", "-f"}) require.True(t, *f) require.True(t, *g) badCases := [][]string{ {"-s"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecRepeatableOptional2OptionChoice(t *testing.T) { var f, g *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") } spec := "[-f|-g]..." //TODO: okCmd(t, spec, init, []string{}) require.False(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) okCmd(t, spec, init, []string{"-f", "-g"}) require.True(t, *f) require.True(t, *g) okCmd(t, spec, init, []string{"-g", "-f"}) require.True(t, *f) require.True(t, *g) badCases := [][]string{ {"-s"}, {"-f", "xxx"}, {"xxx", "-f"}, } for _, args := range badCases { t.Run(fmt.Sprintf("badCase: %#v", args), func(t *testing.T) { failCmd(t, spec, init, args) }) } } func TestSpecOption3Choice(t *testing.T) { var f, g, h *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") h = c.BoolOpt("x", false, "") } spec := "-f|-g|-x" //TODO okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) require.False(t, *h) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) require.False(t, *h) okCmd(t, spec, init, []string{"-x"}) require.False(t, *f) require.False(t, *g) require.True(t, *h) } func TestSpecOptionalOption3Choice(t *testing.T) { var f, g, h *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") h = c.BoolOpt("x", false, "") } spec := "[-f|-g|-x]" okCmd(t, spec, init, []string{}) require.False(t, *f) require.False(t, *g) require.False(t, *h) okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) require.False(t, *h) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) require.False(t, *h) okCmd(t, spec, init, []string{"-x"}) require.False(t, *f) require.False(t, *g) require.True(t, *h) } func TestSpecC1(t *testing.T) { var f, g *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") } spec := "-f|-g..." // spec = "[-f|-g...]" okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) okCmd(t, spec, init, []string{"-g", "-g"}) require.False(t, *f) require.True(t, *g) } func TestSpecC2(t *testing.T) { var f, g *bool init := func(c *Cmd) { f = c.BoolOpt("f", false, "") g = c.BoolOpt("g", false, "") } spec := "[-f|-g...]" okCmd(t, spec, init, []string{}) require.False(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) require.False(t, *g) okCmd(t, spec, init, []string{"-g"}) require.False(t, *f) require.True(t, *g) okCmd(t, spec, init, []string{"-g", "-g"}) require.False(t, *f) require.True(t, *g) } func TestSpecCpCase(t *testing.T) { var f, g *[]string init := func(c *Cmd) { f = c.StringsArg("SRC", nil, "") g = c.StringsArg("DST", nil, "") } spec := "SRC... DST" okCmd(t, spec, init, []string{"A", "B"}) require.Equal(t, []string{"A"}, *f) require.Equal(t, []string{"B"}, *g) okCmd(t, spec, init, []string{"A", "B", "C"}) require.Equal(t, []string{"A", "B"}, *f) require.Equal(t, []string{"C"}, *g) okCmd(t, spec, init, []string{"A", "B", "C", "D"}) require.Equal(t, []string{"A", "B", "C"}, *f) require.Equal(t, []string{"D"}, *g) } func TestSpecC3(t *testing.T) { var f, g *[]string init := func(c *Cmd) { f = c.StringsArg("SRC", nil, "") g = c.StringsArg("DST", nil, "") } spec := "(SRC... DST) | SRC" okCmd(t, spec, init, []string{"A"}) require.Equal(t, []string{"A"}, *f) require.Equal(t, 0, len(*g)) okCmd(t, spec, init, []string{"A", "B"}) require.Equal(t, []string{"A"}, *f) require.Equal(t, []string{"B"}, *g) okCmd(t, spec, init, []string{"A", "B", "C"}) require.Equal(t, []string{"A", "B"}, *f) require.Equal(t, []string{"C"}, *g) okCmd(t, spec, init, []string{"A", "B", "C", "D"}) require.Equal(t, []string{"A", "B", "C"}, *f) require.Equal(t, []string{"D"}, *g) } func TestSpecC5(t *testing.T) { var f, g *[]string var x *bool init := func(c *Cmd) { f = c.StringsArg("SRC", nil, "") g = c.StringsArg("DST", nil, "") x = c.BoolOpt("x", false, "") } spec := "(SRC... -x DST) | (SRC... DST)" okCmd(t, spec, init, []string{"A", "B"}) require.Equal(t, []string{"A"}, *f) require.Equal(t, []string{"B"}, *g) require.False(t, *x) okCmd(t, spec, init, []string{"A", "B", "C"}) require.Equal(t, []string{"A", "B"}, *f) require.Equal(t, []string{"C"}, *g) require.False(t, *x) okCmd(t, spec, init, []string{"A", "B", "-x", "C"}) require.Equal(t, []string{"A", "B"}, *f) require.Equal(t, []string{"C"}, *g) require.True(t, *x) } func TestSpecOptionsEndExplicit(t *testing.T) { var x *[]string init := func(c *Cmd) { x = c.StringsArg("X", nil, "") } spec := "-- X..." okCmd(t, spec, init, []string{"A"}) require.Equal(t, []string{"A"}, *x) okCmd(t, spec, init, []string{"--", "A"}) require.Equal(t, []string{"A"}, *x) okCmd(t, spec, init, []string{"--", "-x"}) require.Equal(t, []string{"-x"}, *x) okCmd(t, spec, init, []string{"--", "A", "B"}) require.Equal(t, []string{"A", "B"}, *x) } func TestSpecOptionsEndImplicit(t *testing.T) { var x *[]string var f *bool init := func(c *Cmd) { x = c.StringsArg("X", nil, "") f = c.BoolOpt("f", false, "") } spec := "-f|X..." okCmd(t, spec, init, []string{"A"}) require.Equal(t, []string{"A"}, *x) okCmd(t, spec, init, []string{"--", "A"}) require.Equal(t, []string{"A"}, *x) okCmd(t, spec, init, []string{"--", "-f"}) require.Equal(t, []string{"-f"}, *x) okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) } func TestSpecChoiceWithOptionsEndInLastPos(t *testing.T) { var x *[]string var f *bool init := func(c *Cmd) { x = c.StringsArg("X", nil, "") f = c.BoolOpt("f", false, "") } spec := "-f|(-- X...)" okCmd(t, spec, init, []string{"A", "B"}) require.Equal(t, []string{"A", "B"}, *x) okCmd(t, spec, init, []string{"--", "-f", "B"}) require.Equal(t, []string{"-f", "B"}, *x) okCmd(t, spec, init, []string{"--", "A", "B"}) require.Equal(t, []string{"A", "B"}, *x) okCmd(t, spec, init, []string{"-f"}) require.True(t, *f) } func TestSpecChoiceWithOptionsEnd(t *testing.T) { init := func(c *Cmd) { c.StringsArg("X", nil, "") c.BoolOpt("f", false, "") } spec := "(-- X...)|-f" badSpec(t, spec, init) } func TestSpecOptionAfterOptionsEnd(t *testing.T) { init := func(c *Cmd) { c.StringsArg("X", nil, "") c.BoolOpt("f", false, "") } spec := "-- X... -f" badSpec(t, spec, init) } func TestSpecOptionAfterOptionsEndInAChoice(t *testing.T) { init := func(c *Cmd) { c.StringsArg("X", nil, "") c.BoolOpt("f", false, "") c.BoolOpt("d", false, "") } spec := "-f | (-- X...) -d" badSpec(t, spec, init) } func TestSpecOptionAfterOptionalOptionsEnd(t *testing.T) { init := func(c *Cmd) { c.StringsArg("X", nil, "") c.BoolOpt("f", false, "") c.BoolOpt("d", false, "") } spec := "-f [-- X] -d" badSpec(t, spec, init) } func TestSpecOptionAfterOptionalOptionsEndInAChoice(t *testing.T) { init := func(c *Cmd) { c.StringsArg("X", nil, "") c.BoolOpt("f", false, "") c.BoolOpt("d", false, "") } spec := "(-f | [-- X]) -d" badSpec(t, spec, init) } func TestSpecOptionAfterOptionsEndIsParsedAsArg(t *testing.T) { init := func(c *Cmd) { c.StringArg("CMD", "", "") c.StringsArg("ARG", nil, "") } spec := "-- CMD [ARG...]" cases := [][]string{ {"ls"}, {"ls", "-l"}, {"ls", "--test"}, {"ls", "--test=true"}, {"ls", "--test", "-f"}, } for _, cas := range cases { t.Run(fmt.Sprintf("%+v", cas), func(t *testing.T) { okCmd(t, spec, init, cas) }) } } func TestSpecSingleDash(t *testing.T) { var path *string var f *bool init := func(c *Cmd) { path = c.StringArg("PATH", "", "'-' can be used to read from stdin' ") f = c.BoolOpt("f", false, "") } spec := "[-f] PATH" okCmd(t, spec, init, []string{"TEST"}) require.Equal(t, "TEST", *path) require.False(t, *f) okCmd(t, spec, init, []string{"-f", "TEST"}) require.Equal(t, "TEST", *path) require.True(t, *f) okCmd(t, spec, init, []string{"-"}) require.Equal(t, "-", *path) require.False(t, *f) okCmd(t, spec, init, []string{"-f", "-"}) require.Equal(t, "-", *path) require.True(t, *f) okCmd(t, spec, init, []string{"--", "-"}) require.Equal(t, "-", *path) require.False(t, *f) okCmd(t, spec, init, []string{"-f", "--", "-"}) require.Equal(t, "-", *path) require.True(t, *f) } func TestSpecOptOrdering(t *testing.T) { var a, b, c *bool var d, e, f *string init := func(cmd *Cmd) { a = cmd.BoolOpt("a", false, "") b = cmd.BoolOpt("b", false, "") c = cmd.BoolOpt("c", false, "") d = cmd.StringOpt("d", "", "") e = cmd.StringArg("E", "", "") f = cmd.StringArg("F", "", "") } cases := []struct { spec string args []string a, b, c bool d, e, f string }{ { "-a -b", []string{"-a", "-b"}, true, true, false, "", "", "", }, { "-a -b", []string{"-b", "-a"}, true, true, false, "", "", "", }, { "-a [-b]", []string{"-a"}, true, false, false, "", "", "", }, { "-a [-b]", []string{"-b", "-a"}, true, true, false, "", "", "", }, { "-a [-b]", []string{"-b", "-a"}, true, true, false, "", "", "", }, { "[-a -b]", []string{"-a", "-b"}, true, true, false, "", "", "", }, { "[-a -b]", []string{"-b", "-a"}, true, true, false, "", "", "", }, { "[-a [-b]]", []string{"-a"}, true, false, false, "", "", "", }, { "[-a [-b]]", []string{"-a", "-b"}, true, true, false, "", "", "", }, { "[-a [-b]]", []string{"-b", "-a"}, true, true, false, "", "", "", }, { "-a | -b -c", []string{"-a", "-c"}, true, false, true, "", "", "", }, { "-a | -b -c", []string{"-c", "-a"}, true, false, true, "", "", "", }, { "-a | -b -c", []string{"-b", "-c"}, false, true, true, "", "", "", }, { "-a | -b -c", []string{"-c", "-b"}, false, true, true, "", "", "", }, { "(-a | -b) (-c | -d)", []string{"-a", "-c"}, true, false, true, "", "", "", }, { "(-a | -b) (-c | -d)", []string{"-c", "-a"}, true, false, true, "", "", "", }, { "(-a | -b) [-c | -d]", []string{"-a"}, true, false, false, "", "", "", }, { "(-a | -b) [-c | -d]", []string{"-a", "-c"}, true, false, true, "", "", "", }, { "(-a | -b) [-c | -d]", []string{"-d=X", "-b"}, false, true, false, "X", "", "", }, { "-a -b E -c -d", []string{"-a", "-b", "E", "-c", "-d", "D"}, true, true, true, "D", "E", "", }, { "-a -b E -c -d", []string{"-a", "-b", "E", "-c", "-d", "D"}, true, true, true, "D", "E", "", }, { "-a -b E -c -d", []string{"-b", "-a", "E", "-c", "-d", "D"}, true, true, true, "D", "E", "", }, { "-a -b E -c -d", []string{"-a", "-b", "E", "-d", "D", "-c"}, true, true, true, "D", "E", "", }, { "-a -d...", []string{"-a", "-d", "1"}, true, false, false, "1", "", "", }, { "-a -d...", []string{"-d", "1", "-d", "2", "-a"}, true, false, false, "2", "", "", }, } for _, cas := range cases { t.Run(fmt.Sprintf("%q :: %#v", cas.spec, cas.args), func(t *testing.T) { okCmd(t, cas.spec, init, cas.args) require.Equal(t, cas.a, *a) require.Equal(t, cas.b, *b) require.Equal(t, cas.c, *c) require.Equal(t, cas.d, *d) require.Equal(t, cas.e, *e) require.Equal(t, cas.f, *f) }) } } func TestSpecOptInlineValue(t *testing.T) { var f, g, x *string var y *[]string init := func(c *Cmd) { f = c.StringOpt("f", "", "") g = c.StringOpt("giraffe", "", "") x = c.StringOpt("x", "", "") y = c.StringsOpt("y", nil, "") } spec := "-x= [ -f= | --giraffe= ] -y=..." okCmd(t, spec, init, []string{"-x=a", "-y=b"}) require.Equal(t, "a", *x) require.Equal(t, []string{"b"}, *y) okCmd(t, spec, init, []string{"-x=a", "-y=b", "-y=c"}) require.Equal(t, "a", *x) require.Equal(t, []string{"b", "c"}, *y) okCmd(t, spec, init, []string{"-x=a", "-f=f", "-y=b"}) require.Equal(t, "a", *x) require.Equal(t, "f", *f) require.Equal(t, []string{"b"}, *y) okCmd(t, spec, init, []string{"-x=a", "--giraffe=g", "-y=b"}) require.Equal(t, "a", *x) require.Equal(t, "g", *g) require.Equal(t, []string{"b"}, *y) } // https://github.com/jawher/mow.cli/issues/28 func TestWardDoesntRunTooSlowly(t *testing.T) { init := func(cmd *Cmd) { _ = cmd.StringOpt("login", "", "Login for credential, e.g. username or email.") _ = cmd.StringOpt("realm", "", "Realm for credential, e.g. website or WiFi AP name.") _ = cmd.StringOpt("note", "", "Note for credential.") _ = cmd.BoolOpt("no-copy", false, "Do not copy generated password to the clipboard.") _ = cmd.BoolOpt("gen", false, "Generate a password.") _ = cmd.IntOpt("length", 0, "Password length.") _ = cmd.IntOpt("min-length", 30, "Minimum length password.") _ = cmd.IntOpt("max-length", 40, "Maximum length password.") _ = cmd.BoolOpt("no-upper", false, "Exclude uppercase characters in password.") _ = cmd.BoolOpt("no-lower", false, "Exclude lowercase characters in password.") _ = cmd.BoolOpt("no-digit", false, "Exclude digit characters in password.") _ = cmd.BoolOpt("no-symbol", false, "Exclude symbol characters in password.") _ = cmd.BoolOpt("no-similar", false, "Exclude similar characters in password.") _ = cmd.IntOpt("min-upper", 0, "Minimum number of uppercase characters in password.") _ = cmd.IntOpt("max-upper", -1, "Maximum number of uppercase characters in password.") _ = cmd.IntOpt("min-lower", 0, "Minimum number of lowercase characters in password.") _ = cmd.IntOpt("max-lower", -1, "Maximum number of lowercase characters in password.") _ = cmd.IntOpt("min-digit", 0, "Minimum number of digit characters in password.") _ = cmd.IntOpt("max-digit", -1, "Maximum number of digit characters in password.") _ = cmd.IntOpt("min-symbol", 0, "Minimum number of symbol characters in password.") _ = cmd.IntOpt("max-symbol", -1, "Maximum number of symbol characters in password.") _ = cmd.StringOpt("exclude", "", "Exclude specific characters from password.") } spec := "[--login] [--realm] [--note] [--no-copy] [--gen [--length] [--min-length] [--max-length] [--no-upper] [--no-lower] [--no-digit] [--no-symbol] [--no-similar] [--min-upper] [--max-upper] [--min-lower] [--max-lower] [--min-digit] [--max-digit] [--min-symbol] [--max-symbol] [--exclude]]" okCmd(t, spec, init, []string{}) okCmd(t, spec, init, []string{"--gen", "--length", "42"}) okCmd(t, spec, init, []string{"--length", "42", "--gen"}) okCmd(t, spec, init, []string{"--min-length", "10", "--length", "42", "--gen"}) okCmd(t, spec, init, []string{"--min-length", "10", "--no-symbol", "--no-lower", "--length", "42", "--gen"}) } func TestEnvOverrideOk(t *testing.T) { defer os.Unsetenv("envopt") cases := []struct { setenv bool spec string args []string envval string }{ // pickup the value from the environment variable {true, "--envopt --other", []string{"--other", "otheropt"}, "fromenv"}, {true, "[--envopt] --other", []string{"--other", "otheropt"}, "fromenv"}, {true, "--envopt", []string{}, "fromenv"}, {true, "--envopt", []string{"--"}, "fromenv"}, // override on command line {true, "--envopt", []string{"-e", "fromopt"}, "fromopt"}, {true, "--envopt", []string{"--envopt", "fromopt"}, "fromopt"}, // no env set {false, "--envopt", []string{"--envopt", "fromopt"}, "fromopt"}, {false, "--envopt", []string{"-e", "fromopt"}, "fromopt"}, // no env var, fallback to default {false, "[--envopt]", []string{}, "envdefault"}, {false, "[--envopt] --other", []string{"--other", "otheropt"}, "envdefault"}, } for _, cas := range cases { t.Run(fmt.Sprintf("%q :: %#v", cas.spec, cas.args), func(t *testing.T) { var envopt *string var otheropt *string init := func(c *Cmd) { os.Unsetenv("envopt") if cas.setenv { os.Setenv("envopt", "fromenv") } envopt = c.String(StringOpt{ Name: "e envopt", Value: "envdefault", EnvVar: "envopt", }) if strings.Contains(cas.spec, "other") { otheropt = c.StringOpt("o other", "", "") } } okCmd(t, cas.spec, init, cas.args) if strings.Contains(cas.spec, "other") { // if the test spec defined --other, make sure it was actually set assert.Equal(t, "otheropt", *otheropt) } // ensure --envopt was actually set to the test's expectations assert.Equal(t, cas.envval, *envopt) }) } } // Anti-regression test for infinite loop case with envvar backed opts // https://github.com/jawher/mow.cli/pull/49 func TestEnvOptSeq(t *testing.T) { defer os.Unsetenv("envopt") var envopt *string var arg *string init := func(c *Cmd) { defer os.Unsetenv("envopt") envopt = c.String(StringOpt{ Name: "e envopt", Value: "envdefault", EnvVar: "envopt", }) arg = c.StringArg("ARG", "", "") } os.Setenv("envopt", "envval") okCmd(t, "", init, []string{"argval"}) assert.Equal(t, "envval", *envopt) assert.Equal(t, "argval", *arg) } // Test that not setting an environment variable correctly causes // required options to fail if no value is supplied in args. func TestEnvOverrideFail(t *testing.T) { os.Unsetenv("envopt") cases := []struct { spec string args []string envval string }{ // no env var, not optional; should fail {"--envopt", []string{}, ""}, {"--envopt --other", []string{"--other", "otheropt"}, ""}, } for _, cas := range cases { t.Run(fmt.Sprintf("%q :: %#v", cas.spec, cas.args), func(t *testing.T) { init := func(c *Cmd) { c.String(StringOpt{ Name: "e envopt", Value: "envdefault", EnvVar: "envopt", }) if strings.Contains(cas.spec, "other") { c.StringOpt("o other", "", "") } } failCmd(t, cas.spec, init, cas.args) }) } } func TestJoinStrings(t *testing.T) { cases := []struct { input []string expected string }{ {nil, ""}, {[]string{""}, ""}, {[]string{" "}, ""}, {[]string{"\t"}, ""}, {[]string{"", " ", "\t"}, ""}, {[]string{"a"}, "a"}, {[]string{"a", "b c"}, "a b c"}, {[]string{"", "a", " ", "b", "\t"}, "a b"}, } for _, cas := range cases { t.Run(fmt.Sprintf("%+v", cas.input), func(t *testing.T) { t.Logf("Testing %#v", cas.input) actual := joinStrings(cas.input...) require.Equal(t, cas.expected, actual) }) } } func TestPrintTabbedRow(t *testing.T) { cases := []struct { s1, s2 string expected string }{ {"", "", " \t\n"}, {"a", "", " a\t\n"}, {"a", "b", " a\tb\n"}, {"a", " b", " a\tb\n"}, {"a", "b\n", " a\tb\n \t\n"}, {"a", "b\nc", " a\tb\n \tc\n"}, } for _, cas := range cases { t.Run(fmt.Sprintf("%q, %q", cas.s1, cas.s2), func(t *testing.T) { t.Logf("Testing %q, %q", cas.s1, cas.s2) var out strings.Builder printTabbedRow(&out, cas.s1, cas.s2) require.Equal(t, cas.expected, out.String()) }) } } mow.cli-1.1.0/doc.go000066400000000000000000000660361346511200500141650ustar00rootroot00000000000000/* Package cli provides a framework to build command line applications in Go with most of the burden of arguments parsing and validation placed on the framework instead of the user. Basics To create a new application, initialize an app with cli.App. Specify a name and a brief description for the application: cp := cli.App("cp", "Copy files around") To attach code to execute when the app is launched, assign a function to the Action field: cp.Action = func() { fmt.Printf("Hello world\n") } To assign a version to the application, use Version method and specify the flags that will be used to invoke the version command: cp.Version("v version", "cp 1.2.3") Finally, in the main func, call Run passing in the arguments for parsing: cp.Run(os.Args) Options To add one or more command line options (also known as flags), use one of the short-form StringOpt, StringsOpt, IntOpt, IntsOpt, Float64Opt, Floats64Opt, or BoolOpt methods on App (or Cmd if adding flags to a command or a subcommand). For example, to add a boolean flag to the cp command that specifies recursive mode, use the following: recursive := cp.BoolOpt("R recursive", false, "recursively copy the src to dst") or: cp.BoolOptPtr(&cfg.recursive, "R recursive", false, "recursively copy the src to dst") The first version returns a new pointer to a bool value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. The option name(s) is a space separated list of names (without the dashes). The one letter names can then be called with a single dash (short option, -R), the others with two dashes (long options, --recursive). You also specify the default value for the option if it is not supplied by the user. The last parameter is the description to be shown in help messages. There is also a second set of methods on App called String, Strings, Int, Ints, and Bool, which accept a long-form struct of the type: cli.StringOpt, cli.StringsOpt, cli.IntOpt, cli.IntsOpt, cli.Float64Opt, cli.Floats64Opt, cli.BoolOpt. The struct describes the option and allows the use of additional features not available in the short-form methods described above: recursive = cp.Bool(cli.BoolOpt{ Name: "R recursive", Value: false, Desc: "copy src files recursively", EnvVar: "VAR_RECURSIVE", SetByUser: &recursiveSetByUser, }) Or: recursive = cp.BoolPtr(&recursive, cli.BoolOpt{ Name: "R recursive", Value: false, Desc: "copy src files recursively", EnvVar: "VAR_RECURSIVE", SetByUser: &recursiveSetByUser, }) The first version returns a new pointer to a value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. Two features, EnvVar and SetByUser, can be defined in the long-form struct method. EnvVar is a space separated list of environment variables used to initialize the option if a value is not provided by the user. When help messages are shown, the value of any environment variables will be displayed. SetByUser is a pointer to a boolean variable that is set to true if the user specified the value on the command line. This can be useful to determine if the value of the option was explicitly set by the user or set via the default value. You can only access the values stored in the pointers in the Action func, which is invoked after argument parsing has been completed. This precludes using the value of one option as the default value of another. On the command line, the following syntaxes are supported when specifying options. Boolean options: -f single dash one letter name -f=false single dash one letter name, equal sign followed by true or false --force double dash for longer option names -it single dash for multiple one letter names (option folding), this is equivalent to: -i -t String, int and float options: -e=value single dash one letter name, equal sign, followed by the value -e value single dash one letter name, space followed by the value -Ivalue single dash one letter name, immediately followed by the value --extra=value double dash for longer option names, equal sign followed by the value --extra value double dash for longer option names, space followed by the value Slice options (StringsOpt, IntsOpt, Floats64Opt) where option is repeated to accumulate values in a slice: -e PATH:/bin -e PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] -ePATH:/bin -ePATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] -e=PATH:/bin -e=PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] --env PATH:/bin --env PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] --env=PATH:/bin --env=PATH:/usr/bin resulting slice contains ["/bin", "/usr/bin"] Arguments To add one or more command line arguments (not prefixed by dashes), use one of the short-form StringArg, StringsArg, IntArg, IntsArg, Float64Arg, Floats64Arg, or BoolArg methods on App (or Cmd if adding arguments to a command or subcommand). For example, to add two string arguments to our cp command, use the following calls: src := cp.StringArg("SRC", "", "the file to copy") dst := cp.StringArg("DST", "", "the destination") Or: cp.StringArgPtr(&src, "SRC", "", "the file to copy") cp.StringArgPtr(&dst, "DST", "", "the destination") The first version returns a new pointer to a value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. You then specify the argument as will be displayed in help messages. Argument names must be specified as all uppercase. The next parameter is the default value for the argument if it is not supplied. And the last is the description to be shown in help messages. There is also a second set of methods on App called String, Strings, Int, Ints, Float64, Floats64 and Bool, which accept a long-form struct of the type: cli.StringArg, cli.StringsArg, cli.IntArg, cli.IntsArg, cli.BoolArg. The struct describes the arguments and allows the use of additional features not available in the short-form methods described above: src = cp.Strings(StringsArg{ Name: "SRC", Desc: "The source files to copy", Value: "default value", EnvVar: "VAR1 VAR2", SetByUser: &srcSetByUser, }) Or: src = cp.StringsPtr(&src, StringsArg{ Name: "SRC", Desc: "The source files to copy", Value: "default value", EnvVar: "VAR1 VAR2", SetByUser: &srcSetByUser, }) The first version returns a new pointer to a value which will be populated when the app is run, whereas the second version will populate a pointer to an existing variable you specify. Two features, EnvVar and SetByUser, can be defined in the long-form struct method. EnvVar is a space separated list of environment variables used to initialize the argument if a value is not provided by the user. When help messages are shown, the value of any environment variables will be displayed. SetByUser is a pointer to a boolean variable that is set to true if the user specified the value on the command line. This can be useful to determine if the value of the argument was explicitly set by the user or set via the default value. You can only access the values stored in the pointers in the Action func, which is invoked after argument parsing has been completed. This precludes using the value of one argument as the default value of another. Operators The -- operator marks the end of command line options. Everything that follows will be treated as an argument, even if starts with a dash. For example, the standard POSIX touch command, which takes a filename as an argument (and possibly other options that we'll ignore here), could be defined as: file := cp.StringArg("FILE", "", "the file to create") If we try to create a file named "-f" via our touch command: $ touch -f It will fail because the -f will be parsed as an option, not as an argument. The fix is to insert -- after all flags have been specified, so the remaining arguments are parsed as arguments instead of options as follows: $ touch -- -f This ensures the -f is parsed as an argument instead of a flag named f. Commands This package supports nesting of commands and subcommands. Declare a top-level command by calling the Command func on the top-level App struct. For example, the following creates an application called docker that will have one command called run: docker := cli.App("docker", "A self-sufficient runtime for linux containers") docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { // initialize the run command here }) The first argument is the name of the command the user will specify on the command line to invoke this command. The second argument is the description of the command shown in help messages. And, the last argument is a CmdInitializer, which is a function that receives a pointer to a Cmd struct representing the command. Within this function, define the options and arguments for the command by calling the same methods as you would with top-level App struct (BoolOpt, StringArg, ...). To execute code when the command is invoked, assign a function to the Action field of the Cmd struct. Within that function, you can safely refer to the options and arguments as command line parsing will be completed at the time the function is invoked: docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { var ( detached = cmd.BoolOpt("d detach", false, "Run container in background") memory = cmd.StringOpt("m memory", "", "Set memory limit") image = cmd.StringArg("IMAGE", "", "The image to run") ) cmd.Action = func() { if *detached { // do something } runContainer(*image, *detached, *memory) } }) Optionally, to provide a more extensive description of the command, assign a string to LongDesc, which is displayed when a user invokes --help. A LongDesc can be provided for Cmds as well as the top-level App: cmd.LongDesc = `Run a command in a new container With the docker run command, an operator can add to or override the image defaults set by a developer. And, additionally, operators can override nearly all the defaults set by the Docker runtime itself. The operator’s ability to override image and Docker runtime defaults is why run has more options than any other docker command.` Subcommands can be added by calling Command on the Cmd struct. They can by defined to any depth if needed: docker.Command("job", "actions on jobs", func(job *cli.Cmd) { job.Command("list", "list jobs", listJobs) job.Command("start", "start a new job", startJob) job.Command("log", "log commands", func(log *cli.Cmd) { log.Command("show", "show logs", showLog) log.Command("clear", "clear logs", clearLog) }) }) Command and subcommand aliases are also supported. To define one or more aliases, specify a space-separated list of strings to the first argument of Command: job.Command("start run r", "start a new job", startJob) With the command structure defined above, users can invoke the app in a variety of ways: $ docker job list $ docker job start $ docker job run # using the alias we defined $ docker job r # using the alias we defined $ docker job log show $ docker job log clear As a convenience, to assign an Action to a func with no arguments, use ActionCommand when defining the Command. For example, the following two statements are equivalent: app.Command("list", "list all configs", cli.ActionCommand(list)) // Exactly the same as above, just more verbose app.Command("list", "list all configs", func(cmd *cli.Cmd)) { cmd.Action = func() { list() } } Please note that options, arguments, specs, and long descriptions cannot be provided when using ActionCommand. This is intended for very simple command invocations that take no arguments. Finally, as a side-note, it may seem a bit weird that this package uses a function to initialize a command instead of simply returning a command struct. The motivation behind this API decision is scoping: as with the standard flag package, adding an option or an argument returns a pointer to a value which will be populated when the app is run. Since you'll want to store these pointers in variables, and to avoid having dozens of them in the same scope (the main func for example or as global variables), this API was specifically tailored to take a func parameter (called CmdInitializer), which accepts the command struct. With this design, the command's specific variables are limited in scope to this function. Interceptors Interceptors, or hooks, can be defined to be executed before and after a command or when any of its subcommands are executed. For example, the following app defines multiple commands as well as a global flag which toggles verbosity: app := cli.App("app", "bla bla") verbose := app.BoolOpt("verbose v", false, "Enable debug logs") app.Command("command1", "...", func(cmd *cli.Cmd) { if (*verbose) { logrus.SetLevel(logrus.DebugLevel) } }) app.Command("command2", "...", func(cmd *cli.Cmd) { if (*verbose) { logrus.SetLevel(logrus.DebugLevel) } }) Instead of duplicating the check for the verbose flag and setting the debug level in every command (and its sub-commands), a Before interceptor can be set on the top-level App instead: app.Before = func() { if (*verbose) { logrus.SetLevel(logrus.DebugLevel) } } Whenever a valid command is called by the user, all the Before interceptors defined on the app and the intermediate commands will be called, in order from the root to the leaf. Similarly, to execute a hook after a command has been called, e.g. to cleanup resources allocated in Before interceptors, simply set the After field of the App struct or any other Command. After interceptors will be called, in order, from the leaf up to the root (the opposite order of the Before interceptors). The following diagram shows when and in which order multiple Before and After interceptors are executed: +------------+ success +------------+ success +----------------+ success | app.Before +---------------> cmd.Before +-------------> sub_cmd.Before +---------+ +------------+ +-+----------+ +--+-------------+ | | | +-v-------+ error | error | | sub_cmd | +-----------------------+ +-----------------------+ | Action | | | +-+-------+ +------v-----+ +-----v------+ +----------------+ | | app.After <---------------+ cmd.After <-------------+ sub_cmd.After <---------+ +------------+ always +------------+ always +----------------+ always Exiting To exit the application, use cli.Exit function, which accepts an exit code and exits the app with the provided code. It is important to use cli.Exit instead of os.Exit as the former ensures that all of the After interceptors are executed before exiting. cli.Exit(1) Spec Strings An App or Command's invocation syntax can be customized using spec strings. This can be useful to indicate that an argument is optional or that two options are mutually exclusive. The spec string is one of the key differentiators between this package and other CLI packages as it allows the developer to express usage in a simple, familiar, yet concise grammar. To define option and argument usage for the top-level App, assign a spec string to the App's Spec field: cp := cli.App("cp", "Copy files around") cp.Spec = "[-R [-H | -L | -P]]" Likewise, to define option and argument usage for a command or subcommand, assign a spec string to the Command's Spec field: docker := cli.App("docker", "A self-sufficient runtime for linux containers") docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { cmd.Spec = "[-d|--rm] IMAGE [COMMAND [ARG...]]" : : } The spec syntax is mostly based on the conventions used in POSIX command line applications (help messages and man pages). This syntax is described in full below. If a user invokes the app or command with the incorrect syntax, the app terminates with a help message showing the proper invocation. The remainder of this section describes the many features and capabilities of the spec string grammar. Options can use both short and long option names in spec strings. In the example below, the option is mandatory and must be provided. Any options referenced in a spec string MUST be explicitly declared, otherwise this package will panic. I.e. for each item in the spec string, a corresponding *Opt or *Arg is required: x.Spec = "-f" // or x.Spec = "--force" forceFlag := x.BoolOpt("f force", ...) Arguments are specified with all-uppercased words. In the example below, both SRC and DST must be provided by the user (two arguments). Like options, any argument referenced in a spec string MUST be explicitly declared, otherwise this package will panic: x.Spec="SRC DST" src := x.StringArg("SRC", ...) dst := x.StringArg("DST", ...) With the exception of options, the order of the elements in a spec string is respected and enforced when command line arguments are parsed. In the example below, consecutive options (-f and -g) are parsed regardless of the order they are specified (both "-f=5 -g=6" and "-g=6 -f=5" are valid). Order between options and arguments is significant (-f and -g must appear before the SRC argument). The same holds true for arguments, where SRC must appear before DST: x.Spec = "-f -g SRC -h DST" var ( factor = x.IntOpt("f", 1, "Fun factor (1-5)") games = x.IntOpt("g", 1, "# of games") health = x.IntOpt("h", 1, "# of hosts") src = x.StringArg("SRC", ...) dst = x.StringArg("DST", ...) ) Optionality of options and arguments is specified in a spec string by enclosing the item in square brackets []. If the user does not provide an optional value, the app will use the default value specified when the argument was defined. In the example below, if -x is not provided, heapSize will default to 1024: x.Spec = "[-x]" heapSize := x.IntOpt("x", 1024, "Heap size in MB") Choice between two or more items is specified in a spec string by separating each choice with the | operator. Choices are mutually exclusive. In the examples below, only a single choice can be provided by the user otherwise the app will terminate displaying a help message on proper usage: x.Spec = "--rm | --daemon" x.Spec = "-H | -L | -P" x.Spec = "-t | DST" Repetition of options and arguments is specified in a spec string with the ... postfix operator to mark an item as repeatable. Both options and arguments support repitition. In the example below, users may invoke the command with multiple -e options and multiple SRC arguments: x.Spec = "-e... SRC..." // Allows parsing of the following shell command: // $ app -eeeee file1 file2 // $ app -e -e -e -e file1 file2 Grouping of options and arguments is specified in a spec string with parenthesis. When combined with the choice | and repetition ... operators, complex syntaxes can be created. The parenthesis in the example below indicate a repeatable sequence of a -e option followed by an argument, and that is mutually exclusive to a choice between -x and -y options. x.Spec = "(-e COMMAND)... | (-x|-y)" // Allows parsing of the following shell command: // $ app -e show -e add // $ app -y // But not the following: // $ app -e show -x Option groups, or option folding, are a shorthand method to declaring a choice between multiple options. I.e. any combination of the listed options in any order with at least one option selected. The following two statements are equivalent: x.Spec = "-abcd" x.Spec = "(-a | -b | -c | -d)..." Option groups are typically used in conjunction with optionality [] operators. I.e. any combination of the listed options in any order or none at all. The following two statements are equivalent: x.Spec = "[-abcd]" x.Spec = "[-a | -b | -c | -d]..." All of the options can be specified using a special syntax: [OPTIONS]. This is a special token in the spec string (not optionality and not an argument called OPTIONS). It is equivalent to an optional repeatable choice between all the available options. For example, if an app or a command declares 4 options a, b, c and d, then the following two statements are equivalent: x.Spec = "[OPTIONS]" x.Spec = "[-a | -b | -c | -d]..." Inline option values are specified in the spec string with the = notation immediately following an option (long or short form) to provide users with an inline description or value. The actual inline values are ignored by the spec parser as they exist only to provide a contextual hint to the user. In the example below, "absolute-path" and "in seconds" are ignored by the parser: x.Spec = "[ -a= | --timeout= ] ARG" The -- operator can be used to automatically treat everything following it as arguments. In other words, placing a -- in the spec string automatically inserts a -- in the same position in the program call arguments. This lets you write programs such as the POSIX time utility for example: x.Spec = "-lp [-- CMD [ARG...]]" // Allows parsing of the following shell command: // $ app -p ps -aux Spec Grammar Below is the full EBNF grammar for the Specs language: spec -> sequence sequence -> choice* req_sequence -> choice+ choice -> atom ('|' atom)* atom -> (shortOpt | longOpt | optSeq | allOpts | group | optional) rep? shortOp -> '-' [A-Za-z] longOpt -> '--' [A-Za-z][A-Za-z0-9]* optSeq -> '-' [A-Za-z]+ allOpts -> '[OPTIONS]' group -> '(' req_sequence ')' optional -> '[' req_sequence ']' rep -> '...' By combining a few of these building blocks together (while respecting the grammar above), powerful and sophisticated validation constraints can be created in a simple and concise manner without having to define in code. This is one of the key differentiators between this package and other CLI packages. Validation of usage is handled entirely by the package through the spec string. Behind the scenes, this package parses the spec string and constructs a finite state machine used to parse the command line arguments. It also handles backtracking, which allows it to handle tricky cases, or what I like to call "the cp test": cp SRC... DST Without backtracking, this deceptively simple spec string cannot be parsed correctly. For instance, docopt can't handle this case, whereas this package does. Default Spec By default an auto-generated spec string is created for the app and every command unless a spec string has been set by the user. This can simplify use of the package even further for simple syntaxes. The following logic is used to create an auto-generated spec string: 1) start with an empty spec string, 2) if at least one option was declared, append "[OPTIONS]" to the spec string, and 3) for each declared argument, append it, in the order of declaration, to the spec string. For example, given this command declaration: docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { var ( detached = cmd.BoolOpt("d detach", false, "Run container in background") memory = cmd.StringOpt("m memory", "", "Set memory limit") image = cmd.StringArg("IMAGE", "", "The image to run") args = cmd.StringsArg("ARG", nil, "Arguments") ) }) The auto-generated spec string, which should suffice for simple cases, would be: [OPTIONS] IMAGE ARG If additional constraints are required, the spec string must be set explicitly using the grammar documented above. Custom Types By default, the following types are supported for options and arguments: bool, string, int, float64, strings (slice of strings), ints (slice of ints) and floats64 (slice of float64). You can, however, extend this package to handle other types, e.g. time.Duration, float64, or even your own struct types. To define your own custom type, you must implement the flag.Value interface for your custom type, and then declare the option or argument using VarOpt or VarArg respectively if using the short-form methods. If using the long-form struct, then use Var instead. The following example defines a custom type for a duration. It defines a duration argument that users will be able to invoke with strings in the form of "1h31m42s": // Declare your type type Duration time.Duration // Make it implement flag.Value func (d *Duration) Set(v string) error { parsed, err := time.ParseDuration(v) if err != nil { return err } *d = Duration(parsed) return nil } func (d *Duration) String() string { duration := time.Duration(*d) return duration.String() } func main() { duration := Duration(0) app := App("var", "") app.VarArg("DURATION", &duration, "") app.Run([]string{"cp", "1h31m42s"}) } To make a custom type to behave as a boolean option, i.e. doesn't take a value, it must implement the IsBoolFlag method that returns true: type BoolLike int func (d *BoolLike) IsBoolFlag() bool { return true } To make a custom type behave as a multi-valued option or argument, i.e. takes multiple values, it must implement the Clear method, which is called whenever the values list needs to be cleared, e.g. when the value was initially populated from an environment variable, and then explicitly set from the CLI: type Durations []time.Duration // Make it implement flag.Value func (d *Durations) Set(v string) error { parsed, err := time.ParseDuration(v) if err != nil { return err } *d = append(*d, Duration(parsed)) return nil } func (d *Durations) String() string { return fmt.Sprintf("%v", *d) } // Make it multi-valued func (d *Durations) Clear() { *d = []Duration{} } To hide the default value of a custom type, it must implement the IsDefault method that returns a boolean. The help message generator will use the return value to decide whether or not to display the default value to users: type Action string func (a *Action) IsDefault() bool { return (*a) == "nop" } */ package cli mow.cli-1.1.0/errors.go000066400000000000000000000002261346511200500147210ustar00rootroot00000000000000package cli import ( "errors" ) var ( errHelpRequested = errors.New("help requested") errVersionRequested = errors.New("version requested") ) mow.cli-1.1.0/examples_test.go000066400000000000000000000131431346511200500162640ustar00rootroot00000000000000package cli_test import ( "fmt" "os" "time" cli "github.com/jawher/mow.cli" ) func Example_greet() { app := cli.App("greet", "Greet") app.Spec = "[NAME]" name := app.String(cli.StringArg{Name: "NAME", Value: "stranger", Desc: "Your name", EnvVar: "USER"}) app.Action = func() { fmt.Printf("Hello %s\n", *name) } app.Run(os.Args) } func Example_cp() { cp := cli.App("cp", "Copy files around") cp.Spec = "[-R [-H | -L | -P]] [-fi | -n] SRC... DST" var ( recursive = cp.BoolOpt("R", false, "copy src files recursively") followSymbolicCL = cp.BoolOpt("H", false, "If the -R option is specified, symbolic links on the command line are followed. (Symbolic links encountered in the tree traversal are not followed.)") followSymbolicTree = cp.BoolOpt("L", false, "If the -R option is specified, all symbolic links are followed.") followSymbolicNo = cp.BoolOpt("P", true, "If the -R option is specified, no symbolic links are followed. This is the default.") force = cp.BoolOpt("f", false, "If the destination file cannot be opened, remove it and create a new file, without prompting for confirmation regardless of its permissions. (The -f option overrides any previous -n option.)") interactive = cp.BoolOpt("i", false, "Cause cp to write a prompt to the standard error output before copying a file that would overwrite an existing file. If the response from the standard input begins with the character `y' or `Y', the file copy is attempted. (The -i option overrides any previous -n option.)") noOverwrite = cp.BoolOpt("f", false, "Do not overwrite an existing file. (The -n option overrides any previous -f or -i options.)") ) var ( src = cp.Strings(cli.StringsArg{ Name: "SRC", Desc: "The source files to copy", }) dst = cp.Strings(cli.StringsArg{Name: "DST", Value: nil, Desc: "The destination directory"}) ) cp.Action = func() { fmt.Printf(`copy: SRC: %v DST: %v recursive: %v follow links (CL, Tree, No): %v %v %v force: %v interactive: %v no overwrite: %v`, *src, *dst, *recursive, *followSymbolicCL, *followSymbolicTree, *followSymbolicNo, *force, *interactive, *noOverwrite) } cp.Run(os.Args) } func Example_docker() { docker := cli.App("docker", "A self-sufficient runtime for linux containers") docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { cmd.Spec = "[-d|--rm] IMAGE [COMMAND [ARG...]]" var ( detached = cmd.Bool(cli.BoolOpt{Name: "d detach", Value: false, Desc: "Detached mode: run the container in the background and print the new container ID"}) rm = cmd.Bool(cli.BoolOpt{Name: "rm", Value: false, Desc: "Automatically remove the container when it exits (incompatible with -d)"}) memory = cmd.String(cli.StringOpt{Name: "m memory", Value: "", Desc: "Memory limit (format: , where unit = b, k, m or g)"}) ) var ( image = cmd.String(cli.StringArg{Name: "IMAGE", Value: "", Desc: ""}) command = cmd.String(cli.StringArg{Name: "COMMAND", Value: "", Desc: "The command to run"}) args = cmd.Strings(cli.StringsArg{Name: "ARG", Value: nil, Desc: "The command arguments"}) ) cmd.Action = func() { var how string switch { case *detached: how = "detached" case *rm: how = "rm after" default: how = "--" } fmt.Printf("Run image %s, command %s, args %v, how? %v, mem %s", *image, *command, *args, how, *memory) } }) docker.Command("pull", "Pull an image or a repository from the registry", func(cmd *cli.Cmd) { cmd.Spec = "[-a] NAME" var ( all = cmd.Bool(cli.BoolOpt{Name: "a all-tags", Value: false, Desc: "Download all tagged images in the repository"}) ) var ( name = cmd.String(cli.StringArg{Name: "NAME", Value: "", Desc: "Image name (optionally NAME:TAG)"}) ) cmd.Action = func() { if *all { fmt.Printf("Download all tags for image %s", *name) return } fmt.Printf("Download image %s", *name) } }) docker.Run(os.Args) } func Example_dockerPtr() { docker := cli.App("docker", "A self-sufficient runtime for linux containers") docker.Command("run", "Run a command in a new container", func(cmd *cli.Cmd) { cmd.Spec = "[-d|--rm] IMAGE [COMMAND [ARG...]]" type RunConfig struct { Detached bool RM bool Memory string Image string Command string Args []string } var cfg RunConfig // options cmd.BoolOptPtr(&cfg.Detached, "d detach", false, "Detached mode: run the container in the background and print the new container ID") cmd.BoolOptPtr(&cfg.RM, "rm", false, "Automatically remove the container when it exits (incompatible with -d)") cmd.StringOptPtr(&cfg.Memory, "m memory", "", "Memory limit (format: , where unit = b, k, m or g)") // args cmd.StringArgPtr(&cfg.Image, "IMAGE", "", "") cmd.StringArgPtr(&cfg.Command, "COMMAND", "", "The command to run") cmd.StringsArgPtr(&cfg.Args, "ARG", nil, "The command arguments") cmd.Action = func() { fmt.Printf("Run using config: %+v", cfg) } }) docker.Run(os.Args) } func Example_beforeAfter() { app := cli.App("app", "App") bench := app.BoolOpt("b bench", false, "Measure execution time") var t0 time.Time app.Before = func() { if *bench { t0 = time.Now() } } app.After = func() { if *bench { d := time.Since(t0) fmt.Printf("Command execution took: %vs", d.Seconds()) } } app.Command("cmd1", "first command", func(cmd *cli.Cmd) { cmd.Action = func() { fmt.Print("Running command 1") } }) app.Command("cmd2", "second command", func(cmd *cli.Cmd) { cmd.Action = func() { fmt.Print("Running command 2") } }) app.Run(os.Args) } mow.cli-1.1.0/examples_vararg_test.go000066400000000000000000000013671346511200500176330ustar00rootroot00000000000000package cli_test import ( "fmt" "github.com/jawher/mow.cli" ) // Declare your type type Counter int // Make it implement flag.Value func (c *Counter) Set(v string) error { *c++ return nil } func (c *Counter) String() string { return fmt.Sprintf("%d", *c) } // Make it a bool option func (c *Counter) IsBoolFlag() bool { return true } func ExampleVarOpt() { app := cli.App("var", "Var opt example") // Declare a variable of your type verbosity := Counter(0) // Call one of the Var methods (arg, opt, ...) to declare your custom type app.VarOpt("v", &verbosity, "verbosity level") app.Action = func() { // The variable will be populated after the app is ran fmt.Print(verbosity) } app.Run([]string{"app", "-vvvvv"}) // Output: 5 } mow.cli-1.1.0/examples_varopt_test.go000066400000000000000000000014751346511200500176640ustar00rootroot00000000000000package cli_test import ( "fmt" "time" "github.com/jawher/mow.cli" ) // Declare your type type Duration time.Duration // Make it implement flag.Value func (d *Duration) Set(v string) error { parsed, err := time.ParseDuration(v) if err != nil { return err } *d = Duration(parsed) return nil } func (d *Duration) String() string { duration := time.Duration(*d) return duration.String() } func ExampleVarArg() { app := cli.App("var", "Var arg example") // Declare a variable of your type duration := Duration(0) // Call one of the Var methods (arg, opt, ...) to declare your custom type app.VarArg("DURATION", &duration, "") app.Action = func() { // The variable will be populated after the app is ran fmt.Print(time.Duration(duration)) } app.Run([]string{"cp", "1h31m42s"}) // Output: 1h31m42s } mow.cli-1.1.0/go.mod000066400000000000000000000001771346511200500141710ustar00rootroot00000000000000module github.com/jawher/mow.cli require ( github.com/stretchr/objx v0.2.0 // indirect github.com/stretchr/testify v1.3.0 ) mow.cli-1.1.0/go.sum000066400000000000000000000016751346511200500142220ustar00rootroot00000000000000github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= mow.cli-1.1.0/internal/000077500000000000000000000000001346511200500146725ustar00rootroot00000000000000mow.cli-1.1.0/internal/container/000077500000000000000000000000001346511200500166545ustar00rootroot00000000000000mow.cli-1.1.0/internal/container/container.go000066400000000000000000000004541346511200500211700ustar00rootroot00000000000000package container import "flag" /* Container holds an option or an arg data */ type Container struct { Name string Desc string EnvVar string Names []string HideValue bool ValueSetFromEnv bool ValueSetByUser *bool Value flag.Value } mow.cli-1.1.0/internal/flow/000077500000000000000000000000001346511200500156415ustar00rootroot00000000000000mow.cli-1.1.0/internal/flow/flow.go000066400000000000000000000020631346511200500171400ustar00rootroot00000000000000package flow /* ExitCode is a value used in a call to panic to signify that code execution should be stopped, before/after listeners executed and finally that the app whould exit with the provided exit code */ type ExitCode int /* Step is the building block of execution flow. It has a code block to run, a success step to go to if the former succeeds, or go to an error step otherwise */ type Step struct { Do func() Success *Step Error *Step Desc string Exiter func(code int) } /* Run call the code block of the step, moves to the success step if the call went ok, opr the the error step otherwise */ func (s *Step) Run(p interface{}) { s.callDo(p) switch { case s.Success != nil: s.Success.Run(p) case p == nil: return default: if code, ok := p.(ExitCode); ok { if s.Exiter != nil { s.Exiter(int(code)) } return } panic(p) } } func (s *Step) callDo(p interface{}) { if s.Do == nil { return } defer func() { if e := recover(); e != nil { if s.Error == nil { panic(p) } s.Error.Run(e) } }() s.Do() } mow.cli-1.1.0/internal/flow/flow_test.go000066400000000000000000000035151346511200500202020ustar00rootroot00000000000000package flow import ( "github.com/stretchr/testify/require" "testing" ) func TestStepCallsDo(t *testing.T) { called := false step := &Step{ Do: func() { called = true }, } step.Run(nil) require.True(t, called, "Step's do wasn't called") } func TestStepCallsSuccessAfterDo(t *testing.T) { calls := 0 step := &Step{ Do: func() { require.Equal(t, 0, calls, "Do should be called first") calls++ }, Success: &Step{ Do: func() { require.Equal(t, 1, calls, "Success should be called second") calls++ }, }, Error: &Step{ Do: func() { t.Fatalf("Error should not have been called") }, }, } step.Run(nil) require.Equal(t, 2, calls, "Both do and success should be called") } func TestStepCallsErrorIfDoPanics(t *testing.T) { defer func() { r := recover() require.Equal(t, 42, r) }() calls := 0 step := &Step{ Do: func() { require.Equal(t, 0, calls, "Do should be called first") calls++ panic(42) }, Success: &Step{ Do: func() { t.Fatalf("Success should not have been called") }, }, Error: &Step{ Do: func() { require.Equal(t, 1, calls, "Error should be called second") calls++ }, }, } step.Run(nil) require.Equal(t, 2, calls, "Both do and error should be called") } func TestStepCallsOsExitIfAskedTo(t *testing.T) { exitCode := -1 step := &Step{Exiter: func(x int) { exitCode = x }} step.Run(ExitCode(42)) require.Equal(t, exitCode, 42, "should have called exit with 42") } func TestStepRethrowsPanic(t *testing.T) { defer func() { require.Equal(t, 42, recover(), "should panicked with the same value") }() step := &Step{} step.Run(42) t.Fatalf("Should have panicked") } func TestStepShouldNopIfNoSuccessNorPanic(t *testing.T) { step := &Step{Exiter: func(x int) { t.Fatalf("Should not have called exit") }} step.Run(nil) } mow.cli-1.1.0/internal/flow/flowdot/000077500000000000000000000000001346511200500173175ustar00rootroot00000000000000mow.cli-1.1.0/internal/flow/flowdot/flowdot.go000066400000000000000000000014471346511200500213320ustar00rootroot00000000000000package flowdot import ( "fmt" "strings" "github.com/jawher/mow.cli/internal/flow" ) /* Dot generates a graphviz dot string representing the a flow */ func Dot(s *flow.Step) string { trs := flowDot(s, map[*flow.Step]bool{}) return fmt.Sprintf("digraph G {\n\trankdir=LR\n%s\n}\n", strings.Join(trs, "\n")) } func flowDot(s *flow.Step, visited map[*flow.Step]bool) []string { var res []string if visited[s] { return res } visited[s] = true if s.Success != nil { res = append(res, fmt.Sprintf("\t\"%s\" -> \"%s\" [label=\"ok\"]", s.Desc, s.Success.Desc)) res = append(res, flowDot(s.Success, visited)...) } if s.Error != nil { res = append(res, fmt.Sprintf("\t\"%s\" -> \"%s\" [label=\"ko\"]", s.Desc, s.Error.Desc)) res = append(res, flowDot(s.Error, visited)...) } return res } mow.cli-1.1.0/internal/fsm/000077500000000000000000000000001346511200500154575ustar00rootroot00000000000000mow.cli-1.1.0/internal/fsm/fsm.go000066400000000000000000000077261346511200500166070ustar00rootroot00000000000000package fsm import ( "sort" "fmt" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/matcher" "github.com/jawher/mow.cli/internal/values" ) /* State is the basic building block in the FSM. A State can be final or not, and has transitions to other states */ type State struct { Terminal bool Transitions StateTransitions } /* Transition links 2 states. If a transition's matcher matches, the next state can be reached */ type Transition struct { Matcher matcher.Matcher Next *State } // StateTransitions is a sortable slice of transitions according to their priorities type StateTransitions []*Transition func (t StateTransitions) Len() int { return len(t) } func (t StateTransitions) Swap(i, j int) { t[i], t[j] = t[j], t[i] } func (t StateTransitions) Less(i, j int) bool { a, b := t[i].Matcher, t[j].Matcher return a.Priority() < b.Priority() } // NewState create a new state func NewState() *State { return &State{Transitions: []*Transition{}} } // T creates a transition between 2 states func (s *State) T(matcher matcher.Matcher, next *State) *State { s.Transitions = append(s.Transitions, &Transition{Matcher: matcher, Next: next}) return next } // Prepare simplifies the FSM and sorts the transitions according to their priorities func (s *State) Prepare() { simplify(s, s, map[*State]bool{}) sortTransitions(s, map[*State]bool{}) } func sortTransitions(s *State, visited map[*State]bool) { if visited[s] { return } visited[s] = true sort.Sort(s.Transitions) for _, tr := range s.Transitions { sortTransitions(tr.Next, visited) } } func simplify(start, s *State, visited map[*State]bool) { if visited[s] { return } visited[s] = true for _, tr := range s.Transitions { simplify(start, tr.Next, visited) } for s.simplifySelf(start) { } } func (s *State) simplifySelf(start *State) bool { for idx, tr := range s.Transitions { if matcher.IsShortcut(tr.Matcher) { next := tr.Next s.Transitions = removeTransitionAt(idx, s.Transitions) for _, tr := range next.Transitions { if !s.has(tr) { s.Transitions = append(s.Transitions, tr) } } if next.Terminal { s.Terminal = true } return true } } return false } func removeTransitionAt(idx int, arr StateTransitions) StateTransitions { res := make([]*Transition, len(arr)-1) copy(res, arr[:idx]) copy(res[idx:], arr[idx+1:]) return res } func (s *State) has(tr *Transition) bool { for _, t := range s.Transitions { if t.Next == tr.Next && t.Matcher == tr.Matcher { return true } } return false } // Parse tries to navigate into the FSM according to the provided args func (s *State) Parse(args []string) error { pc := matcher.NewParseContext() ok := s.apply(args, pc) if !ok { return fmt.Errorf("incorrect usage") } if err := fillContainers(pc.Opts); err != nil { return err } return fillContainers(pc.Args) } func fillContainers(containers map[*container.Container][]string) error { for con, vs := range containers { if multiValued, ok := con.Value.(values.MultiValued); ok { multiValued.Clear() } for _, v := range vs { if err := con.Value.Set(v); err != nil { return err } } con.ValueSetFromEnv = false if con.ValueSetByUser != nil { *con.ValueSetByUser = true } } return nil } func (s *State) apply(args []string, pc matcher.ParseContext) bool { if s.Terminal && len(args) == 0 { return true } if len(args) > 0 { arg := args[0] if !pc.RejectOptions && arg == "--" { pc.RejectOptions = true args = args[1:] } } type match struct { tr *Transition rem []string pc matcher.ParseContext } var matches []*match for _, tr := range s.Transitions { fresh := matcher.NewParseContext() fresh.RejectOptions = pc.RejectOptions if ok, rem := tr.Matcher.Match(args, &fresh); ok { matches = append(matches, &match{tr, rem, fresh}) } } for _, m := range matches { if ok := m.tr.Next.apply(m.rem, m.pc); ok { pc.Merge(m.pc) return true } } return false } mow.cli-1.1.0/internal/fsm/fsm_apply_test.go000066400000000000000000000072141346511200500210430ustar00rootroot00000000000000package fsm_test import ( "testing" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/fsm/fsmtest" "github.com/jawher/mow.cli/internal/matcher" "github.com/jawher/mow.cli/internal/values" "github.com/stretchr/testify/require" ) func TestApplyTerminalStateNoArgs(t *testing.T) { s := fsm.NewState() s.Terminal = true err := s.Parse(nil) require.NoError(t, err) } func TestApply(t *testing.T) { var ( testArgs = []string{"1", "2", "3"} optStrs []string optCon = &container.Container{ Value: values.NewStrings(&optStrs, nil), } argStrs []string argCon = &container.Container{ Value: values.NewStrings(&argStrs, nil), } calls []string ) matchers := map[string]matcher.Matcher{ "a": fsmtest.TestMatcher{ TestPriority: 2, MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, testArgs, args) calls = append(calls, "a") c.Opts[optCon] = []string{"a.opt"} c.Args[argCon] = []string{"a.arg"} return true, args[1:] }, }, "b": fsmtest.TestMatcher{ TestPriority: 1, MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, testArgs, args) calls = append(calls, "b") c.Opts[optCon] = []string{"b.opt"} c.Args[argCon] = []string{"b.arg"} return true, args[1:] }, }, "c": fsmtest.TestMatcher{ TestPriority: 1, MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, testArgs[1:], args, "second stage matchers should be called with the rem args") calls = append(calls, "c") c.Opts[optCon] = []string{"c.opt"} c.Args[argCon] = []string{"c.arg"} return true, args[1:] }, }, "d": fsmtest.TestMatcher{ TestPriority: 1, MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, testArgs[1:], args, "second stage matchers should be called with the rem args") calls = append(calls, "d") c.Opts[optCon] = []string{"d.opt"} c.Args[argCon] = []string{"d.arg"} return false, args[1:] }, }, "e": fsmtest.TestMatcher{ TestPriority: 1, MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, testArgs[2:], args, "third stage matchers should be called with the rem args") calls = append(calls, "e") c.Opts[optCon] = []string{"e.opt"} c.Args[argCon] = []string{"e.arg"} return true, nil }, }, } s := fsmtest.NewFsm(` S1 a S2 S1 b S3 S2 c S4 S3 d S4 S4 e (S5) `, matchers) s.Prepare() err := s.Parse(testArgs) require.Equal(t, []string{"b", "a", "d", "c", "e"}, calls) require.NoError(t, err) require.Equal(t, []string{"a.opt", "c.opt", "e.opt"}, optStrs) require.Equal(t, []string{"a.arg", "c.arg", "e.arg"}, argStrs) } func TestApplyRejectOptions(t *testing.T) { var ( testArgs = []string{"1", "--", "2"} calls []string ) matchers := map[string]matcher.Matcher{ "a": fsmtest.TestMatcher{ MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, testArgs, args) require.False(t, c.RejectOptions) calls = append(calls, "a") return true, args[1:] }, }, "b": fsmtest.TestMatcher{ MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { require.Equal(t, []string{"2"}, args) require.True(t, c.RejectOptions) calls = append(calls, "b") return true, args[1:] }, }, } s := fsmtest.NewFsm(` S1 a S2 S2 b (S3) `, matchers) s.Prepare() err := s.Parse(testArgs) require.NoError(t, err) require.Equal(t, []string{"a", "b"}, calls) } mow.cli-1.1.0/internal/fsm/fsm_parse_test.go000066400000000000000000000033461346511200500210320ustar00rootroot00000000000000package fsm_test import ( "testing" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/fsm/fsmtest" "github.com/jawher/mow.cli/internal/matcher" "github.com/jawher/mow.cli/internal/values" "github.com/stretchr/testify/require" ) func TestParseErrorsWhenApplyReturnsFalse(t *testing.T) { s := fsm.NewState() err := s.Parse(nil) require.Error(t, err) } func TestParseNoErrorWhenApplyReturnsTrue(t *testing.T) { s := fsm.NewState() s.Terminal = true err := s.Parse(nil) require.NoError(t, err) } func TestParseFillsContainers(t *testing.T) { var ( boolSetByUser = false boolVar = false stringsSetByUser = false stringsVar []string boolCon = &container.Container{ Value: values.NewBool(&boolVar, false), ValueSetFromEnv: true, ValueSetByUser: &boolSetByUser, } stringsCon = &container.Container{ Value: values.NewStrings(&stringsVar, []string{"original", "value"}), ValueSetFromEnv: true, ValueSetByUser: &stringsSetByUser, } ) matchers := map[string]matcher.Matcher{ "^": fsmtest.TestMatcher{ TestPriority: 2, MatchFunc: func(args []string, c *matcher.ParseContext) (bool, []string) { c.Opts[boolCon] = []string{"true"} c.Args[stringsCon] = []string{"new", "value"} return true, nil }, }, } s := fsmtest.NewFsm(` S1 ^ (S2) `, matchers) s.Prepare() err := s.Parse([]string{"something"}) require.NoError(t, err) require.False(t, boolCon.ValueSetFromEnv) require.True(t, boolSetByUser) require.True(t, boolVar) require.False(t, stringsCon.ValueSetFromEnv) require.True(t, stringsSetByUser) require.Equal(t, stringsVar, []string{"new", "value"}) } mow.cli-1.1.0/internal/fsm/fsm_prepare_test.go000066400000000000000000000030701346511200500213500ustar00rootroot00000000000000package fsm_test import ( "testing" "github.com/jawher/mow.cli/internal/fsm/fsmtest" "github.com/jawher/mow.cli/internal/matcher" "github.com/jawher/mow.cli/internal/matcher/matchertest" "github.com/stretchr/testify/require" ) var ( testMatchers = map[string]matcher.Matcher{ "*": matcher.NewShortcut(), "!": fsmtest.NopeMatcher{}, "-a": matchertest.NewOpt("-a"), "ARG": matchertest.NewArg("ARG"), "--": matcher.NewOptsEnd(), "-abc": matchertest.NewOptions("-abc"), } ) func TestSimplify(t *testing.T) { cases := []struct { original string simplified string }{ { original: ` S1 * S2 S2 -a (S3) `, simplified: "S1 -a (S3)", }, { // seq like FSM original: ` S1 * S2 S2 -a S3 S3 * S2 S3 * (S4) `, simplified: ` S1 -a (S3) (S3) -a (S3) `, }, { // optional transition FSM original: ` S1 -a S2 S2 * (S3) S1 * (S3) `, simplified: ` (S1) -a (S2) `, }, } for _, cas := range cases { t.Logf("FSM.simplify:\noriginal: %s\nexpected: %s", cas.original, cas.simplified) original := fsmtest.NewFsm(cas.original, testMatchers) original.Prepare() simplified := fsmtest.NewFsm(cas.simplified, testMatchers) require.Equal(t, fsmtest.FsmStr(simplified), fsmtest.FsmStr(original)) } } func TestSort(t *testing.T) { s := fsmtest.NewFsm(` S1 * S2 S1 * S3 S1 ARG S2 S1 -- S2 S1 -abc S2 S1 -a S3 `, testMatchers) s.Prepare() require.Equal(t, []string{"-a", "-abc", "ARG", "--"}, fsmtest.TransitionStrs(s.Transitions)) } mow.cli-1.1.0/internal/fsm/fsmdot/000077500000000000000000000000001346511200500167535ustar00rootroot00000000000000mow.cli-1.1.0/internal/fsm/fsmdot/fsmdot.go000066400000000000000000000022131346511200500205740ustar00rootroot00000000000000package fsmdot import ( "fmt" "strings" "github.com/jawher/mow.cli/internal/fsm" ) // Dot generates a graphviz dot representation of an FSM func Dot(s *fsm.State) string { trs := dot(s, mkStateNames(), map[*fsm.State]struct{}{}) return fmt.Sprintf("digraph G {\n\trankdir=LR\n%s\n}\n", strings.Join(trs, "\n")) } func dot(s *fsm.State, sn *stateNames, visited map[*fsm.State]struct{}) []string { var res []string if _, ok := visited[s]; ok { return res } id := sn.id(s) visited[s] = struct{}{} attrs := "" if s.Terminal { attrs = " [peripheries=2]" } res = append(res, fmt.Sprintf("\tS%d%s", id, attrs)) for _, tr := range s.Transitions { res = append(res, fmt.Sprintf("\tS%d -> S%d [label=\"%v\"]", id, sn.id(tr.Next), tr.Matcher)) res = append(res, dot(tr.Next, sn, visited)...) } return res } func mkStateNames() *stateNames { return &stateNames{ counter: 1, ids: map[*fsm.State]int{}, } } type stateNames struct { counter int ids map[*fsm.State]int } func (sn *stateNames) id(s *fsm.State) int { res := sn.ids[s] if res != 0 { return res } res = sn.counter sn.ids[s] = res sn.counter++ return res } mow.cli-1.1.0/internal/fsm/fsmdot/fsmdot_test.go000066400000000000000000000012101346511200500216270ustar00rootroot00000000000000package fsmdot import ( "testing" "strings" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/fsm/fsmtest" "github.com/stretchr/testify/require" ) func TestDot(t *testing.T) { s1 := fsm.NewState() s2 := fsm.NewState() s3 := fsm.NewState() s3.Terminal = true s1.T(fsmtest.YepMatcher{}, s2) s1.T(fsmtest.YepMatcher{}, s3) s2.T(fsmtest.NopeMatcher{}, s3) str := Dot(s1) str = strings.TrimSpace(str) expected := strings.TrimSpace(` digraph G { rankdir=LR S1 S1 -> S2 [label=""] S2 S2 -> S3 [label=""] S3 [peripheries=2] S1 -> S3 [label=""] }`) require.Equal(t, expected, str) } mow.cli-1.1.0/internal/fsm/fsmtest/000077500000000000000000000000001346511200500171445ustar00rootroot00000000000000mow.cli-1.1.0/internal/fsm/fsmtest/fsmtest.go000066400000000000000000000106501346511200500211620ustar00rootroot00000000000000package fsmtest import ( "fmt" "sort" "strings" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/matcher" ) // NopeMatcher is a matcher that always fails type NopeMatcher struct{} // Match always returns false without consuming any args func (NopeMatcher) Match(args []string, c *matcher.ParseContext) (bool, []string) { return false, args } // Priority returns the magic value 666 func (NopeMatcher) Priority() int { return 666 } func (NopeMatcher) String() string { return "" } // YepMatcher is a matcher that always succeeds without consuming any args type YepMatcher struct{} // Match always returns true without consuming any args func (YepMatcher) Match(args []string, c *matcher.ParseContext) (bool, []string) { return true, args } // Priority returns the magic value 666 func (YepMatcher) Priority() int { return 666 } func (YepMatcher) String() string { return "" } // TestMatcher is a matcher with a configurable match function and priority type TestMatcher struct { MatchFunc func(args []string, c *matcher.ParseContext) (bool, []string) TestPriority int } // Match executes the provided match func func (t TestMatcher) Match(args []string, c *matcher.ParseContext) (bool, []string) { return t.MatchFunc(args, c) } // Priority returns the provided priority func (t TestMatcher) Priority() int { return t.TestPriority } /* NewFsm constructs an FSM from the provided string spec and a list of defined matchers The spec syntax is: S1 t1 S2 S2 t2 (S3) states between parenthesis are final states */ func NewFsm(spec string, matchers map[string]matcher.Matcher) *fsm.State { states := map[string]*fsm.State{} lines := strings.FieldsFunc(spec, func(r rune) bool { return r == '\n' }) var res *fsm.State for _, line := range lines { if strings.TrimSpace(line) == "" { continue } parts := strings.Fields(line) if len(parts) != 3 { panic(fmt.Sprintf("Invalid line %q: syntax: START TR END", line)) } sn, tn, en := parts[0], parts[1], parts[2] sn, sterm := stateNameTerm(sn) en, eterm := stateNameTerm(en) s, ok := states[sn] if !ok { s = fsm.NewState() states[sn] = s } s.Terminal = s.Terminal || sterm if res == nil { res = s } e, ok := states[en] if !ok { e = fsm.NewState() states[en] = e } e.Terminal = e.Terminal || eterm t, ok := matchers[tn] if !ok { panic(fmt.Sprintf("Unknown matcher %q in line %q", tn, line)) } s.T(t, e) } return res } // TransitionStrs returns a string slice with the transitions names func TransitionStrs(trs fsm.StateTransitions) []string { var res []string for _, tr := range trs { res = append(res, fmt.Sprintf("%v", tr.Matcher)) } return res } func stateNameTerm(name string) (string, bool) { if strings.HasPrefix(name, "(") { if strings.HasSuffix(name, ")") { name = name[1 : len(name)-1] return name, true } panic(fmt.Sprintf("Invalid state name %q", name)) } return name, false } func mkStateNames() *stateNames { return &stateNames{ counter: 1, ids: map[*fsm.State]int{}, } } type stateNames struct { counter int ids map[*fsm.State]int } func (sn *stateNames) id(s *fsm.State) int { res := sn.ids[s] if res != 0 { return res } res = sn.counter sn.ids[s] = res sn.counter++ return res } func stateName(s *fsm.State, sn *stateNames) string { id := sn.id(s) if !s.Terminal { return fmt.Sprintf("S%d", id) } return fmt.Sprintf("(S%d)", id) } // FsmStr generates a string representation of the provided FSM func FsmStr(s *fsm.State) string { lines := fsmStrVis(s, mkStateNames(), map[*fsm.State]struct{}{}) sort.Sort(lines) return strings.Join(lines, "\n") } func fsmStrVis(s *fsm.State, sn *stateNames, visited map[*fsm.State]struct{}) fsmStrings { if _, ok := visited[s]; ok { return nil } visited[s] = struct{}{} res := fsmStrings{} for _, tr := range s.Transitions { res = append(res, fmt.Sprintf("%s %v %s", stateName(s, sn), tr.Matcher, stateName(tr.Next, sn))) res = append(res, fsmStrVis(tr.Next, sn, visited)...) } return res } type fsmStrings []string func (t fsmStrings) Len() int { return len(t) } func (t fsmStrings) Swap(i, j int) { t[i], t[j] = t[j], t[i] } func (t fsmStrings) Less(i, j int) bool { a := strings.TrimFunc(t[i], isParen) b := strings.TrimFunc(t[j], isParen) return strings.Compare(a, b) < 0 } func isParen(r rune) bool { return r == '(' || r == ')' } mow.cli-1.1.0/internal/fsm/fsmtest/fsmtest_test.go000066400000000000000000000043711346511200500222240ustar00rootroot00000000000000package fsmtest import ( "testing" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/matcher" "github.com/stretchr/testify/require" ) func TestNopeMatcher(t *testing.T) { m := NopeMatcher{} require.Equal(t, 666, m.Priority()) pc := matcher.NewParseContext() args := []string{"a", "b"} ok, rem := m.Match(args, &pc) require.False(t, ok) require.Equal(t, args, rem) } func TestYepMatcher(t *testing.T) { m := YepMatcher{} require.Equal(t, 666, m.Priority()) pc := matcher.NewParseContext() args := []string{"a", "b"} ok, rem := m.Match(args, &pc) require.True(t, ok) require.Equal(t, args, rem) } func TestTestMatcher(t *testing.T) { called := false args := []string{"a", "b"} m := TestMatcher{ MatchFunc: func(targs []string, c *matcher.ParseContext) (bool, []string) { called = true require.Equal(t, args, targs) return true, targs }, TestPriority: 7, } require.Equal(t, 7, m.Priority()) pc := matcher.NewParseContext() ok, rem := m.Match(args, &pc) require.True(t, called) require.True(t, ok) require.Equal(t, args, rem) } func TestNewFsm(t *testing.T) { matchers := map[string]matcher.Matcher{ "a": YepMatcher{}, "b": NopeMatcher{}, } s1 := NewFsm(` S1 a S2 S2 b (S3) `, matchers) require.NotNil(t, s1) require.False(t, s1.Terminal) require.Equal(t, len(s1.Transitions), 1) ta := s1.Transitions[0] require.Equal(t, ta.Matcher, matchers["a"]) s2 := ta.Next require.NotNil(t, s2) require.False(t, s2.Terminal) require.Equal(t, len(s2.Transitions), 1) tb := s2.Transitions[0] require.Equal(t, tb.Matcher, matchers["b"]) s3 := tb.Next require.NotNil(t, s3) require.True(t, s3.Terminal) require.Equal(t, len(s3.Transitions), 0) } func TestTransitionStrs(t *testing.T) { trs := fsm.StateTransitions{ &fsm.Transition{ Matcher: NopeMatcher{}, }, &fsm.Transition{ Matcher: YepMatcher{}, }, } actual := TransitionStrs(trs) require.Equal(t, []string{"", ""}, actual) } func TestFsmStr(t *testing.T) { s1 := fsm.NewState() s2 := fsm.NewState() s3 := fsm.NewState() s3.Terminal = true s1.T(YepMatcher{}, s2) s1.T(YepMatcher{}, s3) s2.T(NopeMatcher{}, s3) str := FsmStr(s1) require.Equal(t, "S1 (S3)\nS1 S2\nS2 (S3)", str) } mow.cli-1.1.0/internal/lexer/000077500000000000000000000000001346511200500160115ustar00rootroot00000000000000mow.cli-1.1.0/internal/lexer/lexer.go000066400000000000000000000117011346511200500174570ustar00rootroot00000000000000package lexer import ( "strings" "fmt" ) // TokenType is a type representing the different kinds of tokens type TokenType string const ( // TTArg is an arg token, e.g. ARG, SRC. DST TTArg TokenType = "Arg" // TTOpenPar ( TTOpenPar TokenType = "OpenPar" // TTClosePar ) TTClosePar TokenType = "ClosePar" // TTOpenSq [ TTOpenSq TokenType = "OpenSq" // TTCloseSq ] TTCloseSq TokenType = "CloseSq" // TTChoice | TTChoice TokenType = "Choice" // TTOptions is the special OPTIONS keyword TTOptions TokenType = "Options" // TTRep ... TTRep TokenType = "Rep" // TTShortOpt -a, -f, ... TTShortOpt TokenType = "ShortOpt" // TTLongOpt --force, --retry, ... TTLongOpt TokenType = "LongOpt" // TTOptSeq a folded option sequence, -rm TTOptSeq TokenType = "OptSeq" // TTOptValue is the special = syntax token TTOptValue TokenType = "OptValue" // TTDoubleDash -- TTDoubleDash TokenType = "DblDash" ) // Token has a type, a value and a position in the input type Token struct { // Type is the token type Typ TokenType // Val the textual content Val string // Pos is the token position in the input Pos int } func (t *Token) String() string { return fmt.Sprintf("%s('%s')@%d", t.Typ, t.Val, t.Pos) } // ParseError represents a parsing error type ParseError struct { // Input is the text to parse Input string // Msg s the error message Msg string // Post is where in the input the error occurred Pos int } func (t *ParseError) ident() string { return strings.Map(func(c rune) rune { switch c { case '\t': return c default: return ' ' } }, t.Input[:t.Pos]) } func (t *ParseError) Error() string { return fmt.Sprintf("Parse error at position %d:\n%s\n%s^ %s", t.Pos, t.Input, t.ident(), t.Msg) } // Tokenize transforms the provided input into a slice of tokens or returns a ParseError func Tokenize(usage string) ([]*Token, error) { pos := 0 var res []*Token var ( tk = func(t TokenType, v string) { res = append(res, &Token{t, v, pos}) } tkp = func(t TokenType, v string, p int) { res = append(res, &Token{t, v, p}) } err = func(msg string) *ParseError { return &ParseError{usage, msg, pos} } ) eof := len(usage) for pos < eof { switch c := usage[pos]; c { case ' ': pos++ case '\t': pos++ case '[': tk(TTOpenSq, "[") pos++ case ']': tk(TTCloseSq, "]") pos++ case '(': tk(TTOpenPar, "(") pos++ case ')': tk(TTClosePar, ")") pos++ case '|': tk(TTChoice, "|") pos++ case '.': start := pos pos++ if pos >= eof || usage[pos] != '.' { return nil, err("Unexpected end of usage, was expecting '..'") } pos++ if pos >= eof || usage[pos] != '.' { return nil, err("Unexpected end of usage, was expecting '.'") } tkp(TTRep, "...", start) pos++ case '-': start := pos pos++ if pos >= eof { return nil, err("Unexpected end of usage, was expecting an option name") } switch o := usage[pos]; { case isLetter(o): pos++ for ; pos < eof; pos++ { ok := isLetter(usage[pos]) if !ok { break } } typ := TTShortOpt opt := usage[start:pos] if pos-start > 2 { typ = TTOptSeq opt = opt[1:] } tkp(typ, opt, start) if pos < eof && usage[pos] == '-' { return nil, err("Invalid syntax") } case o == '-': pos++ if pos == eof || usage[pos] == ' ' { tkp(TTDoubleDash, "--", start) continue } for pos0 := pos; pos < eof; pos++ { ok := isOkLongOpt(usage[pos], pos == pos0) if !ok { break } } opt := usage[start:pos] if len(opt) == 2 { return nil, err("Was expecting a long option name") } tkp(TTLongOpt, opt, start) } case '=': start := pos pos++ if pos >= eof || usage[pos] != '<' { return nil, err("Unexpected end of usage, was expecting '=<'") } closed := false for ; pos < eof; pos++ { closed = usage[pos] == '>' if closed { break } } if !closed { return nil, err("Unclosed option value") } if pos-start == 2 { return nil, err("Was expecting an option value") } pos++ value := usage[start:pos] tkp(TTOptValue, value, start) default: switch { case isUppercase(c): start := pos for pos = pos + 1; pos < eof; pos++ { if !isOkInArg(usage[pos]) { break } } s := usage[start:pos] typ := TTArg if s == "OPTIONS" { typ = TTOptions } tkp(typ, s, start) default: return nil, err("Unexpected input") } } } return res, nil } func isLowercase(c uint8) bool { return c >= 'a' && c <= 'z' } func isUppercase(c uint8) bool { return c >= 'A' && c <= 'Z' } func isOkInArg(c uint8) bool { return isUppercase(c) || isDigit(c) || c == '_' } func isLetter(c uint8) bool { return isLowercase(c) || isUppercase(c) } func isDigit(c uint8) bool { return c >= '0' && c <= '9' } func isOkLongOpt(c uint8, first bool) bool { return isLetter(c) || isDigit(c) || c == '_' || (!first && c == '-') } mow.cli-1.1.0/internal/lexer/lexer_test.go000066400000000000000000000104731346511200500205230ustar00rootroot00000000000000package lexer import ( "testing" "github.com/stretchr/testify/require" ) func TestTokenize(t *testing.T) { cases := []struct { usage string expected []*Token }{ {"OPTIONS", []*Token{{TTOptions, "OPTIONS", 0}}}, {"XOPTIONS", []*Token{{TTArg, "XOPTIONS", 0}}}, {"OPTIONSX", []*Token{{TTArg, "OPTIONSX", 0}}}, {"ARG", []*Token{{TTArg, "ARG", 0}}}, {"ARG42", []*Token{{TTArg, "ARG42", 0}}}, {"ARG_EXTRA", []*Token{{TTArg, "ARG_EXTRA", 0}}}, {"ARG1 ARG2", []*Token{{TTArg, "ARG1", 0}, {TTArg, "ARG2", 5}}}, {"ARG1 ARG2", []*Token{{TTArg, "ARG1", 0}, {TTArg, "ARG2", 6}}}, {"(", []*Token{{TTOpenPar, "(", 0}}}, {")", []*Token{{TTClosePar, ")", 0}}}, {"(ARG)", []*Token{{TTOpenPar, "(", 0}, {TTArg, "ARG", 1}, {TTClosePar, ")", 4}}}, {"( ARG )", []*Token{{TTOpenPar, "(", 0}, {TTArg, "ARG", 2}, {TTClosePar, ")", 6}}}, {"[ARG]", []*Token{{TTOpenSq, "[", 0}, {TTArg, "ARG", 1}, {TTCloseSq, "]", 4}}}, {"[ ARG ]", []*Token{{TTOpenSq, "[", 0}, {TTArg, "ARG", 2}, {TTCloseSq, "]", 6}}}, {"ARG [ARG2 ]", []*Token{{TTArg, "ARG", 0}, {TTOpenSq, "[", 4}, {TTArg, "ARG2", 5}, {TTCloseSq, "]", 10}}}, {"ARG [ ARG2]", []*Token{{TTArg, "ARG", 0}, {TTOpenSq, "[", 4}, {TTArg, "ARG2", 6}, {TTCloseSq, "]", 10}}}, {"...", []*Token{{TTRep, "...", 0}}}, {"ARG...", []*Token{{TTArg, "ARG", 0}, {TTRep, "...", 3}}}, {"ARG ...", []*Token{{TTArg, "ARG", 0}, {TTRep, "...", 4}}}, {"[ARG...]", []*Token{{TTOpenSq, "[", 0}, {TTArg, "ARG", 1}, {TTRep, "...", 4}, {TTCloseSq, "]", 7}}}, {"|", []*Token{{TTChoice, "|", 0}}}, {"ARG|ARG2", []*Token{{TTArg, "ARG", 0}, {TTChoice, "|", 3}, {TTArg, "ARG2", 4}}}, {"ARG |ARG2", []*Token{{TTArg, "ARG", 0}, {TTChoice, "|", 4}, {TTArg, "ARG2", 5}}}, {"ARG| ARG2", []*Token{{TTArg, "ARG", 0}, {TTChoice, "|", 3}, {TTArg, "ARG2", 5}}}, {"[OPTIONS]", []*Token{{TTOpenSq, "[", 0}, {TTOptions, "OPTIONS", 1}, {TTCloseSq, "]", 8}}}, {"-p", []*Token{{TTShortOpt, "-p", 0}}}, {"-X", []*Token{{TTShortOpt, "-X", 0}}}, {"--force", []*Token{{TTLongOpt, "--force", 0}}}, {"--sig-proxy", []*Token{{TTLongOpt, "--sig-proxy", 0}}}, {"-aBc", []*Token{{TTOptSeq, "aBc", 0}}}, {"--", []*Token{{TTDoubleDash, "--", 0}}}, {"=", []*Token{{TTOptValue, "=", 0}}}, {"=", []*Token{{TTOptValue, "=", 0}}}, {"=", []*Token{{TTOptValue, "=", 0}}}, {"-p=", []*Token{{TTShortOpt, "-p", 0}, {TTOptValue, "=", 2}}}, {"--path=", []*Token{{TTLongOpt, "--path", 0}, {TTOptValue, "=", 6}}}, } for _, c := range cases { t.Run(c.usage, func(t *testing.T) { t.Logf("test %s", c.usage) tks, err := Tokenize(c.usage) if err != nil { t.Errorf("[Tokenize '%s']: Unexpected error: %v", c.usage, err) return } t.Logf("actual: %v\n", tks) if len(tks) != len(c.expected) { t.Errorf("[Tokenize '%s']: token count mismatch:\n\tExpected: %v\n\tActual : %v", c.usage, c.expected, tks) return } for i, actual := range tks { expected := c.expected[i] switch { case actual.Typ != expected.Typ: t.Errorf("[Tokenize '%s']: token type mismatch:\n\tExpected: %v\n\tActual : %v", c.usage, expected, actual) case actual.Val != expected.Val: t.Errorf("[Tokenize '%s']: token text mismatch:\n\tExpected: %v\n\tActual : %v", c.usage, expected, actual) case actual.Pos != expected.Pos: t.Errorf("[Tokenize '%s']: token pos mismatch:\n\tExpected: %v\n\tActual : %v", c.usage, expected, actual) } } }) } } func TestTokenizeErrors(t *testing.T) { cases := []struct { usage string pos int }{ {".", 1}, {"A.", 2}, {"A.x", 2}, {"..", 2}, {"ARG..", 5}, {"ARG..x", 5}, {"-", 1}, {"---x", 2}, {"-x-", 2}, {"=", 1}, {"=<", 2}, {"=", 2}, {"a", 0}, {"ARg", 2}, {"1ARG", 0}, } for _, c := range cases { t.Run(c.usage, func(t *testing.T) { t.Logf("test case %q", c.usage) tks, err := Tokenize(c.usage) require.Errorf(t, err, "Tokenize('%s') should have failed, instead got %v", c.usage, tks) perr, ok := err.(*ParseError) require.True(t, ok, "The returned error should be a *ParseError but instead got %#v", err) t.Logf("Got expected error %v", err) if perr.Pos != c.pos { t.Errorf("[Tokenize '%s']: error pos mismatch:\n\tExpected: %v\n\tActual : %v", c.usage, c.pos, perr.Pos) } }) } } mow.cli-1.1.0/internal/matcher/000077500000000000000000000000001346511200500163155ustar00rootroot00000000000000mow.cli-1.1.0/internal/matcher/arg.go000066400000000000000000000012141346511200500174130ustar00rootroot00000000000000package matcher import ( "strings" "github.com/jawher/mow.cli/internal/container" ) // NewArg creates an (positional) argument matcher func NewArg(a *container.Container) Matcher { return &arg{arg: a} } type arg struct { arg *container.Container } func (arg *arg) Match(args []string, c *ParseContext) (bool, []string) { if len(args) == 0 { return false, args } if !c.RejectOptions && strings.HasPrefix(args[0], "-") && args[0] != "-" { return false, args } c.Args[arg.arg] = append(c.Args[arg.arg], args[0]) return true, args[1:] } func (*arg) Priority() int { return 8 } func (arg *arg) String() string { return arg.arg.Name } mow.cli-1.1.0/internal/matcher/arg_test.go000066400000000000000000000022311346511200500204520ustar00rootroot00000000000000package matcher import ( "testing" "github.com/jawher/mow.cli/internal/container" "github.com/stretchr/testify/require" ) func TestArgMatcher(t *testing.T) { a := &container.Container{Name: "X"} argMatcher := arg{arg: a} require.Equal(t, "X", argMatcher.String()) { pc := NewParseContext() args := []string(nil) ok, nargs := argMatcher.Match(args, &pc) require.False(t, ok, "arg should not match") require.Nil(t, nargs, "arg should not consume anything") require.Nil(t, pc.Args[a], "arg should not store anything") } { pc := NewParseContext() args := []string{"a", "b"} ok, nargs := argMatcher.Match(args, &pc) require.True(t, ok, "arg should match") require.Equal(t, []string{"b"}, nargs, "arg should consume the matched value") require.Equal(t, []string{"a"}, pc.Args[a], "arg should stored the matched value") } { pc := NewParseContext() ok, _ := argMatcher.Match([]string{"-v"}, &pc) require.False(t, ok, "arg should not match options") } { pc := NewParseContext() pc.RejectOptions = true ok, _ := argMatcher.Match([]string{"-v"}, &pc) require.True(t, ok, "arg should match options when the reject flag is set") } } mow.cli-1.1.0/internal/matcher/context.go000066400000000000000000000016641346511200500203370ustar00rootroot00000000000000package matcher import "github.com/jawher/mow.cli/internal/container" // ParseContext holds the state of the arguments parsing, i.e. the encountered options and arguments values, etc. type ParseContext struct { Args map[*container.Container][]string Opts map[*container.Container][]string ExcludedOpts map[*container.Container]struct{} RejectOptions bool } // NewParseContext create a new ParseContext func NewParseContext() ParseContext { return ParseContext{ Args: map[*container.Container][]string{}, Opts: map[*container.Container][]string{}, ExcludedOpts: map[*container.Container]struct{}{}, RejectOptions: false, } } // Merge adds the values in the provided context in the current context func (pc ParseContext) Merge(o ParseContext) { for k, vs := range o.Args { pc.Args[k] = append(pc.Args[k], vs...) } for k, vs := range o.Opts { pc.Opts[k] = append(pc.Opts[k], vs...) } } mow.cli-1.1.0/internal/matcher/context_test.go000066400000000000000000000022141346511200500213660ustar00rootroot00000000000000package matcher import ( "testing" "github.com/jawher/mow.cli/internal/container" "github.com/stretchr/testify/require" ) func TestNew(t *testing.T) { c := NewParseContext() require.NotNil(t, c.Args) require.Empty(t, c.Args) require.NotNil(t, c.Opts) require.Empty(t, c.Opts) require.NotNil(t, c.ExcludedOpts) require.Empty(t, c.ExcludedOpts) require.False(t, c.RejectOptions) } func TestMerge(t *testing.T) { var ( a1 = &container.Container{} a2 = &container.Container{} a3 = &container.Container{} o1 = &container.Container{} o2 = &container.Container{} o3 = &container.Container{} ) c1, c2 := NewParseContext(), NewParseContext() c1.Args[a1] = []string{"a1"} c1.Args[a3] = []string{"a3"} c1.Opts[o1] = []string{"o1"} c1.Opts[o3] = []string{"o3"} c2.Args[a1] = []string{"a1.2"} c2.Args[a2] = []string{"a2"} c2.Opts[o1] = []string{"o1.2"} c2.Opts[o2] = []string{"o2"} c1.Merge(c2) require.Equal(t, map[*container.Container][]string{ a1: {"a1", "a1.2"}, a2: {"a2"}, a3: {"a3"}, }, c1.Args) require.Equal(t, map[*container.Container][]string{ o1: {"o1", "o1.2"}, o2: {"o2"}, o3: {"o3"}, }, c1.Opts) } mow.cli-1.1.0/internal/matcher/matchers.go000066400000000000000000000012721346511200500204540ustar00rootroot00000000000000package matcher /* Matcher is used to parse and consume the args and populate the ParseContext */ type Matcher interface { /* Match examines the provided args and: - likes it, fills the parse context and returns true and the remaining args it didn't consume - doesn't like it, returns false and the remaining args it didn't consume */ Match(args []string, c *ParseContext) (bool, []string) // Priority used to sort matchers. the lower the returned number, the higher the priority of the matcher Priority() int } // IsShortcut is a helper to determine whether a given matcher is a Shortcut (always matches) func IsShortcut(matcher Matcher) bool { _, ok := matcher.(shortcut) return ok } mow.cli-1.1.0/internal/matcher/matchers_test.go000066400000000000000000000031721346511200500215140ustar00rootroot00000000000000package matcher import ( "testing" "fmt" "github.com/stretchr/testify/require" ) func TestIsShortcut(t *testing.T) { var ( shortcut = NewShortcut() optsEnd = NewOptsEnd() opt = NewOpt(nil, nil) arg = NewArg(nil) options = NewOptions(nil, nil) ) require.True(t, IsShortcut(shortcut)) require.False(t, IsShortcut(optsEnd)) require.False(t, IsShortcut(opt)) require.False(t, IsShortcut(arg)) require.False(t, IsShortcut(options)) } func TestPriority(t *testing.T) { var ( shortcut = NewShortcut() optsEnd = NewOptsEnd() opt = NewOpt(nil, nil) arg = NewArg(nil) options = NewOptions(nil, nil) ) cases := []struct { a, b Matcher }{ // shorcut always comes last {opt, shortcut}, {arg, shortcut}, {options, shortcut}, {optsEnd, shortcut}, // then comes optsEnd {opt, optsEnd}, {arg, optsEnd}, {options, optsEnd}, // opt comes before the rest {opt, options}, {opt, arg}, // options comes before arg {options, arg}, } for _, cas := range cases { t.Run(fmt.Sprintf("%T < %T", cas.a, cas.b), func(t *testing.T) { ap := cas.a.Priority() bp := cas.b.Priority() require.Truef(t, ap < bp, "%#v (priority=%d) should be < then %#v (priority=%d)", cas.a, ap, cas.b, bp) }) } } func TestMatchersComparable(t *testing.T) { // this stupid-looking test is here for a reason: // It ensures that all exposed matchers from this package are comparable types matchers := []Matcher{ NewShortcut(), NewOpt(nil, nil), NewOptions(nil, nil), NewArg(nil), NewOptsEnd(), } for _, m1 := range matchers { for _, m2 := range matchers { _ = m1 == m2 } } } mow.cli-1.1.0/internal/matcher/matchertest/000077500000000000000000000000001346511200500206405ustar00rootroot00000000000000mow.cli-1.1.0/internal/matcher/matchertest/matchertest.go000066400000000000000000000026111346511200500235120ustar00rootroot00000000000000package matchertest import ( "strings" "fmt" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/matcher" "github.com/jawher/mow.cli/internal/values" ) // NewArg creates a positional argument matcher given its name, e.g. SRC func NewArg(name string) matcher.Matcher { var s string con := &container.Container{ Name: name, Names: []string{name}, Value: values.NewString(&s, ""), } return matcher.NewArg(con) } // NewOpt creates a short and long option matcher given its (space separated) names, e.g. -f --force func NewOpt(name string) matcher.Matcher { s := "" names := strings.Fields(name) con := &container.Container{ Name: name, Names: names, Value: values.NewString(&s, ""), } index := map[string]*container.Container{} for _, n := range names { index[n] = con } return matcher.NewOpt(con, index) } // NewOptions create an options matcher given their names, e.g. -abc func NewOptions(names string) matcher.Matcher { names = strings.TrimPrefix(names, "-") var cons []*container.Container index := map[string]*container.Container{} for _, r := range names { name := fmt.Sprintf("%c", r) var s string fname := "-" + name con := &container.Container{ Name: fname, Names: []string{fname}, Value: values.NewString(&s, ""), } cons = append(cons, con) index[fname] = con } return matcher.NewOptions(cons, index) } mow.cli-1.1.0/internal/matcher/option.go000066400000000000000000000100661346511200500201570ustar00rootroot00000000000000package matcher import ( "strings" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/values" ) // NewOpt create an option matcher that can consume short and long options func NewOpt(o *container.Container, index map[string]*container.Container) Matcher { return &opt{ theOne: o, index: index, } } type opt struct { theOne *container.Container index map[string]*container.Container } func (*opt) Priority() int { return 1 } func (o *opt) String() string { return o.theOne.Names[0] } func (o *opt) Match(args []string, c *ParseContext) (bool, []string) { if len(args) == 0 || c.RejectOptions { return o.theOne.ValueSetFromEnv, args } idx := 0 for idx < len(args) { arg := args[idx] switch { case arg == "-": idx++ case arg == "--": return o.theOne.ValueSetFromEnv, args case strings.HasPrefix(arg, "--"): matched, consumed, nargs := o.matchLongOpt(args, idx, c) if matched { return true, nargs } if consumed == 0 { return o.theOne.ValueSetFromEnv, args } idx += consumed case strings.HasPrefix(arg, "-"): matched, consumed, nargs := o.matchShortOpt(args, idx, c) if matched { return true, nargs } if consumed == 0 { return o.theOne.ValueSetFromEnv, args } idx += consumed default: return o.theOne.ValueSetFromEnv, args } } return o.theOne.ValueSetFromEnv, args } func (o *opt) matchLongOpt(args []string, idx int, c *ParseContext) (bool, int, []string) { arg := args[idx] kv := strings.SplitN(arg, "=", 2) name := kv[0] opt, found := o.index[name] if !found { return false, 0, args } switch { case len(kv) == 2: if opt != o.theOne { return false, 1, args } value := kv[1] if value == "" { return false, 0, args } c.Opts[o.theOne] = append(c.Opts[o.theOne], value) return true, 1, removeStringAt(idx, args) case values.IsBool(opt.Value): if opt != o.theOne { return false, 1, args } c.Opts[o.theOne] = append(c.Opts[o.theOne], "true") return true, 1, removeStringAt(idx, args) default: if len(args[idx:]) < 2 { return false, 0, args } if opt != o.theOne { return false, 2, args } value := args[idx+1] if strings.HasPrefix(value, "-") { return false, 0, args } c.Opts[o.theOne] = append(c.Opts[o.theOne], value) return true, 2, removeStringsBetween(idx, idx+1, args) } } func (o *opt) matchShortOpt(args []string, idx int, c *ParseContext) (bool, int, []string) { arg := args[idx] if len(arg) < 2 { return false, 0, args } if strings.HasPrefix(arg[2:], "=") { name := arg[0:2] opt := o.index[name] if opt != o.theOne { return false, 1, args } value := arg[3:] if value == "" { return false, 0, args } c.Opts[o.theOne] = append(c.Opts[o.theOne], value) return true, 1, removeStringAt(idx, args) } rem := arg[1:] remIdx := 0 for len(rem[remIdx:]) > 0 { name := "-" + rem[remIdx:remIdx+1] opt, found := o.index[name] if !found { return false, 0, args } if values.IsBool(opt.Value) { if opt != o.theOne { remIdx++ continue } c.Opts[o.theOne] = append(c.Opts[o.theOne], "true") newRem := rem[:remIdx] + rem[remIdx+1:] if newRem == "" { return true, 1, removeStringAt(idx, args) } return true, 0, replaceStringAt(idx, "-"+newRem, args) } value := rem[remIdx+1:] if value == "" { if len(args[idx+1:]) == 0 { return false, 0, args } if opt != o.theOne { return false, 2, args } value = args[idx+1] if strings.HasPrefix(value, "-") { return false, 0, args } c.Opts[o.theOne] = append(c.Opts[o.theOne], value) newRem := rem[:remIdx] if newRem == "" { return true, 2, removeStringsBetween(idx, idx+1, args) } nargs := replaceStringAt(idx, "-"+newRem, args) return true, 1, removeStringAt(idx+1, nargs) } if opt != o.theOne { return false, 1, args } c.Opts[o.theOne] = append(c.Opts[o.theOne], value) newRem := rem[:remIdx] if newRem == "" { return true, 1, removeStringAt(idx, args) } return true, 0, replaceStringAt(idx, "-"+newRem, args) } return false, 1, args } mow.cli-1.1.0/internal/matcher/option_test.go000066400000000000000000000132571346511200500212230ustar00rootroot00000000000000package matcher import ( "testing" "fmt" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/values" "github.com/stretchr/testify/require" ) func TestBoolOptMatcher(t *testing.T) { forceOpt := &container.Container{Names: []string{"-f", "--force"}, Value: values.NewBool(new(bool), false)} optMatcher := opt{ theOne: forceOpt, index: map[string]*container.Container{ "-f": forceOpt, "--force": forceOpt, "-g": {Names: []string{"-g"}, Value: values.NewBool(new(bool), false)}, "-x": {Names: []string{"-x"}, Value: values.NewBool(new(bool), false)}, "-y": {Names: []string{"-y"}, Value: values.NewBool(new(bool), false)}, }, } require.Equal(t, "-f", optMatcher.String()) cases := []struct { args []string nargs []string val []string }{ {[]string{"-f", "x"}, []string{"x"}, []string{"true"}}, {[]string{"-f=true", "x"}, []string{"x"}, []string{"true"}}, {[]string{"-f=false", "x"}, []string{"x"}, []string{"false"}}, {[]string{"--force", "x"}, []string{"x"}, []string{"true"}}, {[]string{"--force=true", "x"}, []string{"x"}, []string{"true"}}, {[]string{"--force=false", "x"}, []string{"x"}, []string{"false"}}, {[]string{"-fgxy", "x"}, []string{"-gxy", "x"}, []string{"true"}}, {[]string{"-gfxy", "x"}, []string{"-gxy", "x"}, []string{"true"}}, {[]string{"-gxfy", "x"}, []string{"-gxy", "x"}, []string{"true"}}, {[]string{"-gxyf", "x"}, []string{"-gxy", "x"}, []string{"true"}}, } for _, cas := range cases { t.Run(fmt.Sprintf("%#v", cas), func(t *testing.T) { t.Logf("Testing case: %#v", cas) pc := NewParseContext() ok, nargs := optMatcher.Match(cas.args, &pc) require.True(t, ok, "opt should match") require.Equal(t, cas.nargs, nargs, "opt should consume the option name") require.Equal(t, cas.val, pc.Opts[forceOpt], "true should stored as the option's value") pc = NewParseContext() pc.RejectOptions = true nok, _ := optMatcher.Match(cas.args, &pc) require.False(t, nok, "opt shouldn't match when rejectOptions flag is set") }) } } func TestOptMatcher(t *testing.T) { names := []string{"-f", "--force"} opts := []*container.Container{ {Names: names, Value: values.NewString(new(string), "")}, {Names: names, Value: values.NewInt(new(int), 0)}, {Names: names, Value: values.NewStrings(new([]string), nil)}, {Names: names, Value: values.NewInts(new([]int), nil)}, } cases := []struct { args []string nargs []string val []string }{ {[]string{"-f", "x"}, []string{}, []string{"x"}}, {[]string{"-f", "x="}, []string{}, []string{"x="}}, {[]string{"-f=x", "y"}, []string{"y"}, []string{"x"}}, {[]string{"-f=x=", "y"}, []string{"y"}, []string{"x="}}, {[]string{"-fx", "y"}, []string{"y"}, []string{"x"}}, {[]string{"-fx=", "y"}, []string{"y"}, []string{"x="}}, {[]string{"-afx", "y"}, []string{"-a", "y"}, []string{"x"}}, {[]string{"-af", "x", "y"}, []string{"-a", "y"}, []string{"x"}}, {[]string{"--force", "x"}, []string{}, []string{"x"}}, {[]string{"--force", "x="}, []string{}, []string{"x="}}, {[]string{"--force=x", "y"}, []string{"y"}, []string{"x"}}, {[]string{"--force=x=", "y"}, []string{"y"}, []string{"x="}}, } for _, cas := range cases { for _, forceOpt := range opts { t.Run(fmt.Sprintf("args %#v ; optValue %#v", cas.args, forceOpt.Value), func(t *testing.T) { t.Logf("Testing with args %#v and optValue %#v", cas.args, forceOpt.Value) optMatcher := opt{ theOne: forceOpt, index: map[string]*container.Container{ "-f": forceOpt, "--force": forceOpt, "-a": {Names: []string{"-a"}, Value: values.NewBool(new(bool), false)}, }, } require.Equal(t, "-f", optMatcher.String()) pc := NewParseContext() ok, nargs := optMatcher.Match(cas.args, &pc) require.True(t, ok, "opt %#v should match args %v, %v", forceOpt, cas.args, values.IsBool(forceOpt.Value)) require.Equal(t, cas.nargs, nargs, "opt should consume the option name") require.Equal(t, cas.val, pc.Opts[forceOpt], "true should stored as the option's value") pc = NewParseContext() pc.RejectOptions = true nok, _ := optMatcher.Match(cas.args, &pc) require.False(t, nok, "opt shouldn't match when rejectOptions flag is set") }) } } } func TestOptNegatives(t *testing.T) { names := []string{"-f", "--force"} opts := []*container.Container{ {Names: names, Value: values.NewString(new(string), "")}, {Names: names, Value: values.NewInt(new(int), 0)}, {Names: names, Value: values.NewStrings(new([]string), nil)}, {Names: names, Value: values.NewInts(new([]int), nil)}, } cases := []struct { args []string }{ {[]string{"-"}}, {[]string{"-", "x"}}, {[]string{"--", "y"}}, {[]string{"-c"}}, {[]string{"--qui"}}, {[]string{"-b"}}, {[]string{"-b", "-z"}}, {[]string{"f", "-z"}}, {[]string{"-f="}}, {[]string{"--force="}}, {[]string{"-b=", "-z"}}, } for _, cas := range cases { for _, forceOpt := range opts { t.Run(fmt.Sprintf("args %#v ; optValue %#v", cas.args, forceOpt.Value), func(t *testing.T) { t.Logf("Testing args %#v with optValue: %#v", cas.args, forceOpt.Value) optMatcher := opt{ theOne: forceOpt, index: map[string]*container.Container{ "-f": forceOpt, "--force": forceOpt, "-a": {Names: []string{"-a"}, Value: values.NewBool(new(bool), false)}, "-b": {Names: []string{"-a"}, Value: values.NewString(new(string), "")}, }, } pc := NewParseContext() ok, nargs := optMatcher.Match(cas.args, &pc) require.False(t, ok, "opt %#v should not match args %v, %v", forceOpt, cas.args, values.IsBool(forceOpt.Value)) require.Equal(t, cas.args, nargs, "opt should not have consumed anything") }) } } } mow.cli-1.1.0/internal/matcher/options.go000066400000000000000000000024211346511200500203360ustar00rootroot00000000000000package matcher import ( "strings" "github.com/jawher/mow.cli/internal/container" ) // NewOptions create an Options matcher which can parse a group of options func NewOptions(opts []*container.Container, index map[string]*container.Container) Matcher { return &options{ options: opts, index: index, } } type options struct { options []*container.Container index map[string]*container.Container } func (*options) Priority() int { return 2 } func (om *options) Match(args []string, c *ParseContext) (bool, []string) { ok, nargs := om.try(args, c) if !ok { return false, args } for { ok, nnargs := om.try(nargs, c) if !ok { return true, nargs } nargs = nnargs } } func (om *options) try(args []string, c *ParseContext) (bool, []string) { if len(args) == 0 || c.RejectOptions { return false, args } for _, o := range om.options { if _, exclude := c.ExcludedOpts[o]; exclude { continue } if ok, nargs := (&opt{theOne: o, index: om.index}).Match(args, c); ok { if o.ValueSetFromEnv { c.ExcludedOpts[o] = struct{}{} } return true, nargs } } return false, args } func (om *options) String() string { names := "-" for _, opt := range om.options { s := strings.TrimPrefix(opt.Names[0], "-") names = names + s } return names } mow.cli-1.1.0/internal/matcher/options_test.go000066400000000000000000000063431346511200500214040ustar00rootroot00000000000000package matcher import ( "testing" "time" "fmt" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/values" "github.com/stretchr/testify/require" ) func TestOptsMatcher(t *testing.T) { opts := options{ options: []*container.Container{ {Names: []string{"-f", "--force"}, Value: values.NewBool(new(bool), false)}, {Names: []string{"-g", "--green"}, Value: values.NewString(new(string), "")}, }, index: map[string]*container.Container{}, } for _, o := range opts.options { for _, n := range o.Names { opts.index[n] = o } } require.Equal(t, "-fg", opts.String()) cases := []struct { args []string nargs []string val [][]string }{ {[]string{"-f", "x"}, []string{"x"}, [][]string{{"true"}, nil}}, {[]string{"-f=false", "y"}, []string{"y"}, [][]string{{"false"}, nil}}, {[]string{"--force", "x"}, []string{"x"}, [][]string{{"true"}, nil}}, {[]string{"--force=false", "y"}, []string{"y"}, [][]string{{"false"}, nil}}, {[]string{"-g", "x"}, []string{}, [][]string{nil, {"x"}}}, {[]string{"-g", "x="}, []string{}, [][]string{nil, {"x="}}}, {[]string{"-g=x", "y"}, []string{"y"}, [][]string{nil, {"x"}}}, {[]string{"-g=x=", "y"}, []string{"y"}, [][]string{nil, {"x="}}}, {[]string{"-gx", "y"}, []string{"y"}, [][]string{nil, {"x"}}}, {[]string{"--green", "x"}, []string{}, [][]string{nil, {"x"}}}, {[]string{"--green", "x="}, []string{}, [][]string{nil, {"x="}}}, {[]string{"--green=x", "y"}, []string{"y"}, [][]string{nil, {"x"}}}, {[]string{"--green=x=", "y"}, []string{"y"}, [][]string{nil, {"x="}}}, {[]string{"-f", "-g", "x", "y"}, []string{"y"}, [][]string{{"true"}, {"x"}}}, {[]string{"-g", "x", "-f", "y"}, []string{"y"}, [][]string{{"true"}, {"x"}}}, {[]string{"-g", "x=", "-f", "y"}, []string{"y"}, [][]string{{"true"}, {"x="}}}, {[]string{"-fg", "x", "y"}, []string{"y"}, [][]string{{"true"}, {"x"}}}, {[]string{"-fgxxx", "y"}, []string{"y"}, [][]string{{"true"}, {"xxx"}}}, } for _, cas := range cases { t.Run(fmt.Sprintf("args %#v ", cas.args), func(t *testing.T) { t.Logf("testing with args %#v", cas.args) pc := NewParseContext() ok, nargs := opts.Match(cas.args, &pc) require.True(t, ok, "opts should match") require.Equal(t, cas.nargs, nargs, "opts should consume the option name") for i, opt := range opts.options { require.Equal(t, cas.val[i], pc.Opts[opt], "the option value for %v should be stored", opt) } pc = NewParseContext() pc.RejectOptions = true nok, _ := opts.Match(cas.args, &pc) require.False(t, nok, "opts shouldn't match when rejectOptions flag is set") }) } } // Issue 55 func TestOptsMatcherInfiniteLoop(t *testing.T) { opts := options{ options: []*container.Container{ {Names: []string{"-g"}, Value: values.NewString(new(string), ""), ValueSetFromEnv: true}, }, index: map[string]*container.Container{}, } for _, o := range opts.options { for _, n := range o.Names { opts.index[n] = o } } done := make(chan struct{}, 1) pc := NewParseContext() go func() { opts.Match([]string{"-x"}, &pc) done <- struct{}{} }() select { case <-done: // nop, everything is good case <-time.After(5 * time.Second): t.Fatalf("Timed out after 5 seconds. Infinite loop in optsMatcher.") } } mow.cli-1.1.0/internal/matcher/optsEnd.go000066400000000000000000000006271346511200500202650ustar00rootroot00000000000000package matcher // NewOptsEnd returns the special matcher that matches the -- operator func NewOptsEnd() Matcher { return theOptsEnd } const ( theOptsEnd = optsEnd(true) ) type optsEnd bool func (optsEnd) Match(args []string, c *ParseContext) (bool, []string) { c.RejectOptions = true return true, args } func (optsEnd) Priority() int { return 9 } func (optsEnd) String() string { return "--" } mow.cli-1.1.0/internal/matcher/optsEnd_test.go000066400000000000000000000007001346511200500213140ustar00rootroot00000000000000package matcher import ( "testing" "github.com/stretchr/testify/require" ) func TestOptsEnd(t *testing.T) { require.Equal(t, "--", theOptsEnd.String()) pc := &ParseContext{} args := []string{"a", "b"} ok, nargs := theOptsEnd.Match(args, pc) require.True(t, ok, "optsEnd always matches") require.Equal(t, args, nargs, "optsEnd doesn't touch the passed args") require.True(t, pc.RejectOptions, "optsEnd sets the rejectOptions flag") } mow.cli-1.1.0/internal/matcher/shortcut.go000066400000000000000000000006311346511200500205170ustar00rootroot00000000000000package matcher type shortcut bool const ( theShortcut = shortcut(true) ) // NewShortcut create a special matcher that always matches and doesn't consume any input func NewShortcut() Matcher { return theShortcut } func (shortcut) Match(args []string, c *ParseContext) (bool, []string) { return true, args } func (shortcut) Priority() int { return 10 } func (shortcut) String() string { return "*" } mow.cli-1.1.0/internal/matcher/shortcut_test.go000066400000000000000000000005671346511200500215660ustar00rootroot00000000000000package matcher import ( "testing" "github.com/stretchr/testify/require" ) func TestShortcut(t *testing.T) { pc := &ParseContext{} args := []string{"a", "b"} ok, nargs := theShortcut.Match(args, pc) require.True(t, ok, "shortcut always matches") require.Equal(t, args, nargs, "shortcut doesn't touch the passed args") require.Equal(t, "*", theShortcut.String()) } mow.cli-1.1.0/internal/matcher/strings.go000066400000000000000000000010311346511200500203300ustar00rootroot00000000000000package matcher func removeStringAt(idx int, arr []string) []string { res := make([]string, len(arr)-1) copy(res, arr[:idx]) copy(res[idx:], arr[idx+1:]) return res } func removeStringsBetween(from, to int, arr []string) []string { res := make([]string, len(arr)-(to-from+1)) copy(res, arr[:from]) copy(res[from:], arr[to+1:]) return res } func replaceStringAt(idx int, with string, arr []string) []string { res := make([]string, len(arr)) copy(res, arr[:idx]) res[idx] = with copy(res[idx+1:], arr[idx+1:]) return res } mow.cli-1.1.0/internal/parser/000077500000000000000000000000001346511200500161665ustar00rootroot00000000000000mow.cli-1.1.0/internal/parser/parser.go000066400000000000000000000126501346511200500200150ustar00rootroot00000000000000package parser import ( "fmt" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/fsm" "github.com/jawher/mow.cli/internal/lexer" "github.com/jawher/mow.cli/internal/matcher" ) // Params are used to cofigure the parser type Params struct { Spec string Options []*container.Container OptionsIdx map[string]*container.Container Args []*container.Container ArgsIdx map[string]*container.Container } // Parse transforms a slice of tokens into an FSM or returns an ParseError func Parse(tokens []*lexer.Token, params Params) (*fsm.State, error) { p := &parser{ spec: params.Spec, options: params.Options, optionsIdx: params.OptionsIdx, args: params.Args, argsIdx: params.ArgsIdx, tokens: tokens, } return p.parse() } type parser struct { spec string options []*container.Container optionsIdx map[string]*container.Container args []*container.Container argsIdx map[string]*container.Container tokens []*lexer.Token tkpos int matchedToken *lexer.Token rejectOptions bool } func (p *parser) parse() (s *fsm.State, err error) { defer func() { if v := recover(); v != nil { pos := len(p.spec) if !p.eof() { pos = p.token().Pos } s = nil switch t, ok := v.(string); ok { case true: err = &lexer.ParseError{Input: p.spec, Msg: t, Pos: pos} default: panic(v) } } }() err = nil var e *fsm.State s, e = p.seq(false) if !p.eof() { s = nil err = &lexer.ParseError{Input: p.spec, Msg: "Unexpected input", Pos: p.token().Pos} return } e.Terminal = true s.Prepare() return } func (p *parser) seq(required bool) (*fsm.State, *fsm.State) { start := fsm.NewState() end := start appendComp := func(s, e *fsm.State) { for _, tr := range s.Transitions { end.T(tr.Matcher, tr.Next) } end = e } if required { s, e := p.choice() appendComp(s, e) } for p.canAtom() { s, e := p.choice() appendComp(s, e) } return start, end } func (p *parser) choice() (*fsm.State, *fsm.State) { start, end := fsm.NewState(), fsm.NewState() add := func(s, e *fsm.State) { start.T(matcher.NewShortcut(), s) e.T(matcher.NewShortcut(), end) } add(p.atom()) for p.found(lexer.TTChoice) { add(p.atom()) } return start, end } func (p *parser) atom() (*fsm.State, *fsm.State) { start := fsm.NewState() var end *fsm.State switch { case p.eof(): panic("Unexpected end of input") case p.found(lexer.TTArg): name := p.matchedToken.Val arg, declared := p.argsIdx[name] if !declared { p.back() panic(fmt.Sprintf("Undeclared arg %s", name)) } end = start.T(matcher.NewArg(arg), fsm.NewState()) case p.found(lexer.TTOptions): if p.rejectOptions { p.back() panic("No options after --") } end = fsm.NewState() start.T(matcher.NewOptions(p.options, p.optionsIdx), end) case p.found(lexer.TTShortOpt): if p.rejectOptions { p.back() panic("No options after --") } name := p.matchedToken.Val opt, declared := p.optionsIdx[name] if !declared { p.back() panic(fmt.Sprintf("Undeclared option %s", name)) } end = start.T(matcher.NewOpt(opt, p.optionsIdx), fsm.NewState()) p.found(lexer.TTOptValue) case p.found(lexer.TTLongOpt): if p.rejectOptions { p.back() panic("No options after --") } name := p.matchedToken.Val opt, declared := p.optionsIdx[name] if !declared { p.back() panic(fmt.Sprintf("Undeclared option %s", name)) } end = start.T(matcher.NewOpt(opt, p.optionsIdx), fsm.NewState()) p.found(lexer.TTOptValue) case p.found(lexer.TTOptSeq): if p.rejectOptions { p.back() panic("No options after --") } end = fsm.NewState() sq := p.matchedToken.Val var opts []*container.Container for i := range sq { sn := sq[i : i+1] opt, declared := p.optionsIdx["-"+sn] if !declared { p.back() panic(fmt.Sprintf("Undeclared option -%s", sn)) } opts = append(opts, opt) } start.T(matcher.NewOptions(opts, p.optionsIdx), end) case p.found(lexer.TTOpenPar): start, end = p.seq(true) p.expect(lexer.TTClosePar) case p.found(lexer.TTOpenSq): start, end = p.seq(true) start.T(matcher.NewShortcut(), end) p.expect(lexer.TTCloseSq) case p.found(lexer.TTDoubleDash): p.rejectOptions = true end = start.T(matcher.NewOptsEnd(), fsm.NewState()) return start, end default: panic("Unexpected input: was expecting a command or a positional argument or an option") } if p.found(lexer.TTRep) { end.T(matcher.NewShortcut(), start) } return start, end } func (p *parser) canAtom() bool { switch { case p.is(lexer.TTArg): return true case p.is(lexer.TTOptions): return true case p.is(lexer.TTShortOpt): return true case p.is(lexer.TTLongOpt): return true case p.is(lexer.TTOptSeq): return true case p.is(lexer.TTOpenPar): return true case p.is(lexer.TTOpenSq): return true case p.is(lexer.TTDoubleDash): return true default: return false } } func (p *parser) found(t lexer.TokenType) bool { if p.is(t) { p.matchedToken = p.token() p.tkpos++ return true } return false } func (p *parser) is(t lexer.TokenType) bool { if p.eof() { return false } return p.token().Typ == t } func (p *parser) expect(t lexer.TokenType) { if !p.found(t) { panic(fmt.Sprintf("Was expecting %v", t)) } } func (p *parser) back() { p.tkpos-- } func (p *parser) eof() bool { return p.tkpos >= len(p.tokens) } func (p *parser) token() *lexer.Token { if p.eof() { return nil } return p.tokens[p.tkpos] } mow.cli-1.1.0/internal/parser/parser_test.go000066400000000000000000000115041346511200500210510ustar00rootroot00000000000000package parser import ( "testing" "strings" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/fsm/fsmtest" "github.com/jawher/mow.cli/internal/lexer" "github.com/stretchr/testify/require" ) var ( optACon = &container.Container{ Name: "-a --all", Names: []string{"-a", "--all"}, } optBCon = &container.Container{ Name: "-b --ball", Names: []string{"-b", "--ball"}, } optsIndex = map[string]*container.Container{ "-a": optACon, "--all": optACon, "-b": optBCon, "--ball": optBCon, } argCon = &container.Container{ Name: "ARG", } argsIndex = map[string]*container.Container{ "ARG": argCon, } ) func TestParse(t *testing.T) { cases := []struct { spec string expectedFsm string }{ { spec: "", expectedFsm: "", }, { spec: "-a", expectedFsm: "S1 -a (S2)", }, { spec: "--all", expectedFsm: "S1 -a (S2)", }, { spec: "-a -b", expectedFsm: ` S1 -a S2 S2 -b (S3) `, }, { spec: "-a | -b", expectedFsm: ` S1 -a (S2) S1 -b (S3) `, }, { spec: "[ -a ]", expectedFsm: ` (S1) -a (S2) `, }, { spec: "-a...", expectedFsm: ` S1 -a (S2) (S2) -a (S2) `, }, { spec: "[-a...]", expectedFsm: ` (S1) -a (S2) (S2) -a (S2) `, }, { spec: "[-a]...", expectedFsm: ` (S1) -a (S2) (S2) -a (S2) `, }, { spec: "-a -b | ARG", expectedFsm: ` S1 -a S2 S2 -b (S3) S2 ARG (S4) `, }, { spec: "-a (-b | ARG)", expectedFsm: ` S1 -a S2 S2 -b (S3) S2 ARG (S4) `, }, { spec: "( -a -b ) | ARG", expectedFsm: ` S1 -a S2 S1 ARG (S4) S2 -b (S3) `, }, { spec: "( -a -b ) | ARG...", expectedFsm: ` S1 -a S2 S1 ARG (S4) S2 -b (S3) (S4) ARG (S4) `, }, { spec: "-ab", expectedFsm: ` S1 -ab (S2) `, }, { spec: "-a -- ARG", expectedFsm: ` S1 -a S2 S2 -- S3 S3 ARG (S4) `, }, { spec: "[OPTIONS]", expectedFsm: ` (S1) -ab (S2) `, }, } for _, cas := range cases { t.Run(cas.spec, func(t *testing.T) { t.Logf("Testing spec %q", cas.spec) tokens, lerr := lexer.Tokenize(cas.spec) require.NoErrorf(t, lerr, "Lexing error %v", lerr) s, perr := Parse(tokens, Params{ Args: []*container.Container{argCon}, ArgsIdx: argsIndex, Options: []*container.Container{optACon, optBCon}, OptionsIdx: optsIndex, Spec: cas.spec, }) require.NoErrorf(t, perr, "Parsing error %v", perr) actualFsm := fsmtest.FsmStr(s) require.Equal(t, cleanFsmStr(cas.expectedFsm), actualFsm) }) } } func TestParseErrors(t *testing.T) { cases := []struct { spec string msg string pos int }{ { spec: "-c", msg: "Undeclared option -c", pos: 0, }, { spec: "--close", msg: "Undeclared option --close", pos: 0, }, { spec: "NOPE", msg: "Undeclared arg NOPE", pos: 0, }, { spec: "ARG -- -a", msg: "No options after --", pos: 7, }, { spec: "ARG -- --all", msg: "No options after --", pos: 7, }, { spec: "ARG -- -ab", msg: "No options after --", pos: 7, }, { spec: "ARG -- [OPTIONS]", msg: "No options after --", pos: 8, }, { spec: "-ac", msg: "Undeclared option -c", pos: 0, }, { spec: ")", msg: "Unexpected input", pos: 0, }, { spec: "]", msg: "Unexpected input", pos: 0, }, { spec: "|", msg: "Unexpected input", pos: 0, }, { spec: "-a |", msg: "Unexpected end of input", pos: 4, }, { spec: "( -a", msg: "Was expecting ClosePar", pos: 4, }, } for _, cas := range cases { t.Run(cas.spec, func(t *testing.T) { t.Logf("Testing spec %q", cas.spec) tokens, lerr := lexer.Tokenize(cas.spec) require.NoErrorf(t, lerr, "Lexing error %v", lerr) _, err := Parse(tokens, Params{ Args: []*container.Container{argCon}, ArgsIdx: argsIndex, Options: []*container.Container{optACon, optBCon}, OptionsIdx: optsIndex, Spec: cas.spec, }) require.Error(t, err, "Parsing should have failed") perr, ok := err.(*lexer.ParseError) require.Truef(t, ok, "the returned error should be of type ParseError, but instead was %T", err) t.Logf("Got expected parse error %v", perr) require.Contains(t, perr.Msg, cas.msg) require.Equal(t, cas.pos, perr.Pos) }) } } func cleanFsmStr(s string) string { lines := strings.FieldsFunc(s, func(r rune) bool { return r == '\n' }) clines := make([]string, 0, len(lines)) for _, line := range lines { cline := strings.TrimSpace(line) if cline == "" { continue } clines = append(clines, cline) } //fmt.Printf("%#v\n", lines) return strings.Join(clines, "\n") } mow.cli-1.1.0/internal/values/000077500000000000000000000000001346511200500161715ustar00rootroot00000000000000mow.cli-1.1.0/internal/values/utils.go000066400000000000000000000017471346511200500176710ustar00rootroot00000000000000package values import ( "flag" "os" "strings" ) // IsBool checks if a given value is a bool value, i.e. implements the BoolValued interface func IsBool(v flag.Value) bool { if bf, ok := v.(BoolValued); ok { return bf.IsBoolFlag() } return false } // SetFromEnv fills a value from a list of env vars func SetFromEnv(into flag.Value, envVars string) bool { multiValued, isMulti := into.(MultiValued) if len(envVars) > 0 { for _, ev := range strings.Fields(envVars) { v := os.Getenv(ev) if len(v) == 0 { continue } if !isMulti { if err := into.Set(v); err == nil { return true } continue } vs := strings.Split(v, ",") if err := setMultivalued(multiValued, vs); err == nil { return true } } } return false } func setMultivalued(into MultiValued, values []string) error { into.Clear() for _, v := range values { v = strings.TrimSpace(v) if err := into.Set(v); err != nil { into.Clear() return err } } return nil } mow.cli-1.1.0/internal/values/utils_test.go000066400000000000000000000111331346511200500207160ustar00rootroot00000000000000package values import ( "reflect" "testing" "flag" "os" "github.com/stretchr/testify/require" ) func TestIsBool(t *testing.T) { require.True(t, IsBool(NewBool(new(bool), false))) require.False(t, IsBool(NewString(new(string), ""))) require.False(t, IsBool(NewInt(new(int), 0))) require.False(t, IsBool(NewStrings(new([]string), nil))) require.False(t, IsBool(NewInts(new([]int), nil))) } func TestSetFromEnv(t *testing.T) { cases := []struct { desc string envVars string setup func() (flag.Value, interface{}) expected bool val interface{} }{ { desc: "No env var", envVars: "", setup: func() (flag.Value, interface{}) { os.Setenv("A", "DoDo") var s string return NewString(&s, "default"), &s }, expected: false, val: "default", }, { desc: "One set env var", envVars: "A", setup: func() (flag.Value, interface{}) { os.Setenv("A", "DoDo") var s string return NewString(&s, "default"), &s }, expected: true, val: "DoDo", }, { desc: "One unset env var", envVars: "A", setup: func() (flag.Value, interface{}) { os.Setenv("A", "") var s string return NewString(&s, "default"), &s }, expected: false, val: "default", }, { desc: "Two env var, both set", envVars: "A B", setup: func() (flag.Value, interface{}) { os.Setenv("A", "Aval") os.Setenv("B", "Bval") var s string return NewString(&s, "default"), &s }, expected: true, val: "Aval", }, { desc: "Two env var, first unset, second set", envVars: "A B", setup: func() (flag.Value, interface{}) { os.Setenv("A", "") os.Setenv("B", "Bval") var s string return NewString(&s, "default"), &s }, expected: true, val: "Bval", }, { desc: "One set env var, invalid value", envVars: "A", setup: func() (flag.Value, interface{}) { os.Setenv("A", "XXX") var i int return NewInt(&i, 12), &i }, expected: false, val: 12, }, { desc: "Two env var, both set, first invalid", envVars: "A B", setup: func() (flag.Value, interface{}) { os.Setenv("A", "XXX") os.Setenv("B", "16") var i int return NewInt(&i, 0), &i }, expected: true, val: 16, }, { desc: "Three env vars, all set, first and last invalid", envVars: "A B C", setup: func() (flag.Value, interface{}) { os.Setenv("A", "XXX") os.Setenv("B", "16") os.Setenv("C", "YYY") var i int return NewInt(&i, 0), &i }, expected: true, val: 16, }, { desc: "Three env vars, all set, first invalid", envVars: "A B C", setup: func() (flag.Value, interface{}) { os.Setenv("A", "XXX") os.Setenv("B", "16") os.Setenv("C", "32") var i int return NewInt(&i, 0), &i }, expected: true, val: 16, }, { desc: "Multi value, one unset env var", envVars: "A", setup: func() (flag.Value, interface{}) { os.Setenv("A", "") var i []int return NewInts(&i, []int{1, 2}), &i }, expected: false, val: []int{1, 2}, }, { desc: "Multi value, one set env var", envVars: "A", setup: func() (flag.Value, interface{}) { os.Setenv("A", "7") var i []int return NewInts(&i, []int{1, 2}), &i }, expected: true, val: []int{7}, }, { desc: "Multi value, one set env var (2)", envVars: "A", setup: func() (flag.Value, interface{}) { os.Setenv("A", "7, 8, 9") var i []int return NewInts(&i, []int{1, 2}), &i }, expected: true, val: []int{7, 8, 9}, }, { desc: "Multi value, 2 env vars, first unset", envVars: "A B", setup: func() (flag.Value, interface{}) { os.Setenv("A", "") os.Setenv("B", "7, 8, 9") var i []int return NewInts(&i, []int{1, 2}), &i }, expected: true, val: []int{7, 8, 9}, }, { desc: "Multi value, 2 env vars, first invalid", envVars: "A B", setup: func() (flag.Value, interface{}) { os.Setenv("A", "10, 11, b") os.Setenv("B", "7, 8, 9") var i []int return NewInts(&i, []int{1, 2}), &i }, expected: true, val: []int{7, 8, 9}, }, } for _, cas := range cases { t.Run(cas.desc, func(t *testing.T) { t.Logf("Case: %s", cas.desc) val, into := cas.setup() actual := SetFromEnv(val, cas.envVars) require.Equal(t, cas.expected, actual) typ := reflect.TypeOf(into) if typ.Kind() != reflect.Ptr { t.Fatalf("config func did not return a pointer") } actualValue := reflect.ValueOf(into).Elem().Interface() require.Equal(t, cas.val, actualValue) }) } } mow.cli-1.1.0/internal/values/values.go000066400000000000000000000172421346511200500200250ustar00rootroot00000000000000package values import ( "flag" "fmt" "strconv" ) // BoolValued is an interface values can implement to indicate that they are a bool option, i.e. can be set without providing a value with just -f for example type BoolValued interface { flag.Value // IsBoolFlag should return true to indicate that this value is a bool value IsBoolFlag() bool } // MultiValued is an interface ti indicate that a value can hold multiple values type MultiValued interface { flag.Value // Clear should clear the list of values Clear() } // DefaultValued in an interface to determine if the value stored is the default value, and thus does not need be shown in the help message type DefaultValued interface { // IsDefault should return true if the value stored is the default value, and thus does not need be shown in the help message IsDefault() bool } /******************************************************************************/ /* BOOL */ /******************************************************************************/ // BoolValue is a flag.Value type holding boolean values type BoolValue bool var ( _ flag.Value = NewBool(new(bool), false) _ BoolValued = NewBool(new(bool), false) _ DefaultValued = NewBool(new(bool), false) ) // NewBool creates a new bool value func NewBool(into *bool, v bool) *BoolValue { *into = v return (*BoolValue)(into) } // Set sets the value from a provided string func (bo *BoolValue) Set(s string) error { b, err := strconv.ParseBool(s) if err != nil { return err } *bo = BoolValue(b) return nil } // IsBoolFlag returns true func (bo *BoolValue) IsBoolFlag() bool { return true } func (bo *BoolValue) String() string { return fmt.Sprintf("%v", *bo) } // IsDefault return true if the bool value is false func (bo *BoolValue) IsDefault() bool { return !bool(*bo) } /******************************************************************************/ /* STRING */ /******************************************************************************/ // StringValue is a flag.Value type holding string values type StringValue string var ( _ flag.Value = NewString(new(string), "") _ DefaultValued = NewString(new(string), "") ) // NewString creates a new string value func NewString(into *string, v string) *StringValue { *into = v return (*StringValue)(into) } // Set sets the value from a provided string func (sa *StringValue) Set(s string) error { *sa = StringValue(s) return nil } func (sa *StringValue) String() string { return fmt.Sprintf("%#v", *sa) } // IsDefault return true if the string value is empty func (sa *StringValue) IsDefault() bool { return string(*sa) == "" } /******************************************************************************/ /* INT */ /******************************************************************************/ // IntValue is a flag.Value type holding int values type IntValue int var ( _ flag.Value = NewInt(new(int), 0) ) // NewInt creates a new int value func NewInt(into *int, v int) *IntValue { *into = v return (*IntValue)(into) } // Set sets the value from a provided string func (ia *IntValue) Set(s string) error { i, err := strconv.ParseInt(s, 10, 64) if err != nil { return err } *ia = IntValue(int(i)) return nil } func (ia *IntValue) String() string { return fmt.Sprintf("%v", *ia) } /******************************************************************************/ /* Float64 */ /******************************************************************************/ // Float64Value is a flag.Value type holding int values type Float64Value float64 var ( _ flag.Value = NewFloat64(new(float64), 0) ) // NewFloat64 creates a new int value func NewFloat64(into *float64, v float64) *Float64Value { *into = v return (*Float64Value)(into) } // Set sets the value from a provided string func (ia *Float64Value) Set(s string) error { i, err := strconv.ParseFloat(s, 64) if err != nil { return err } *ia = Float64Value(i) return nil } func (ia *Float64Value) String() string { return fmt.Sprintf("%v", *ia) } /******************************************************************************/ /* STRINGS */ /******************************************************************************/ // StringsValue is a flag.Value type holding string slices values type StringsValue []string var ( _ flag.Value = NewStrings(new([]string), nil) _ MultiValued = NewStrings(new([]string), nil) _ DefaultValued = NewStrings(new([]string), nil) ) // NewStrings creates a new multi-string value func NewStrings(into *[]string, v []string) *StringsValue { *into = v return (*StringsValue)(into) } // Set sets the value from a provided string func (sa *StringsValue) Set(s string) error { *sa = append(*sa, s) return nil } func (sa *StringsValue) String() string { res := "[" for idx, s := range *sa { if idx > 0 { res += ", " } res += fmt.Sprintf("%#v", s) } return res + "]" } // Clear clears the slice func (sa *StringsValue) Clear() { *sa = nil } // IsDefault return true if the string slice is empty func (sa *StringsValue) IsDefault() bool { return len(*sa) == 0 } /******************************************************************************/ /* INTS */ /******************************************************************************/ // IntsValue is a flag.Value type holding int values type IntsValue []int var ( _ flag.Value = NewInts(new([]int), nil) _ MultiValued = NewInts(new([]int), nil) _ DefaultValued = NewInts(new([]int), nil) ) // NewInts creates a new multi-int value func NewInts(into *[]int, v []int) *IntsValue { *into = v return (*IntsValue)(into) } // Set sets the value from a provided string func (ia *IntsValue) Set(s string) error { i, err := strconv.ParseInt(s, 10, 64) if err != nil { return err } *ia = append(*ia, int(i)) return nil } func (ia *IntsValue) String() string { res := "[" for idx, s := range *ia { if idx > 0 { res += ", " } res += fmt.Sprintf("%v", s) } return res + "]" } // Clear clears the slice func (ia *IntsValue) Clear() { *ia = nil } // IsDefault return true if the int slice is empty func (ia *IntsValue) IsDefault() bool { return len(*ia) == 0 } /******************************************************************************/ /* FLOATs64 */ /******************************************************************************/ // Floats64Value is a flag.Value type holding int values type Floats64Value []float64 var ( _ flag.Value = NewFloats64(new([]float64), nil) _ MultiValued = NewFloats64(new([]float64), nil) _ DefaultValued = NewFloats64(new([]float64), nil) ) // NewFloats64 creates a new multi-int value func NewFloats64(into *[]float64, v []float64) *Floats64Value { *into = v return (*Floats64Value)(into) } // Set sets the value from a provided string func (ia *Floats64Value) Set(s string) error { i, err := strconv.ParseFloat(s, 64) if err != nil { return err } *ia = append(*ia, i) return nil } func (ia *Floats64Value) String() string { res := "[" for idx, s := range *ia { if idx > 0 { res += ", " } res += fmt.Sprintf("%v", s) } return res + "]" } // Clear clears the slice func (ia *Floats64Value) Clear() { *ia = nil } // IsDefault return true if the int slice is empty func (ia *Floats64Value) IsDefault() bool { return len(*ia) == 0 } mow.cli-1.1.0/internal/values/values_test.go000066400000000000000000000143141346511200500210610ustar00rootroot00000000000000package values import ( "testing" "flag" "fmt" "github.com/stretchr/testify/require" ) func TestBoolParam(t *testing.T) { var into bool param := NewBool(&into, false) require.True(t, param.IsBoolFlag()) cases := []struct { input string err bool result bool string string }{ {"true", false, true, "true"}, {"false", false, false, "false"}, {"123", true, false, ""}, {"", true, false, ""}, } for _, cas := range cases { t.Logf("testing .Set() with %q", cas.input) err := param.Set(cas.input) if cas.err { require.Errorf(t, err, "value %q should have returned an error", cas.input) continue } require.Equal(t, cas.result, into) require.Equal(t, cas.string, param.String()) } defCases := []struct { value bool isDefault bool }{ {value: false, isDefault: true}, {value: true, isDefault: false}, } for _, cas := range defCases { t.Run(fmt.Sprintf("%v", cas.value), func(t *testing.T) { t.Logf("testing .IsDefault() with %v", cas.value) v := NewBool(&into, cas.value) require.Equal(t, cas.isDefault, v.IsDefault()) }) } } func TestStringParam(t *testing.T) { var into string param := NewString(&into, "") cases := []struct { input string string string }{ {"a", `"a"`}, {"", `""`}, } for _, cas := range cases { t.Run(cas.input, func(t *testing.T) { t.Logf("testing with %q", cas.input) err := param.Set(cas.input) require.NoError(t, err) require.Equal(t, cas.input, into) require.Equal(t, cas.string, param.String()) }) } defCases := []struct { value string isDefault bool }{ {value: "", isDefault: true}, {value: "a", isDefault: false}, } for _, cas := range defCases { t.Run(cas.value, func(t *testing.T) { t.Logf("testing .IsDefault() with %v", cas.value) v := NewString(&into, cas.value) require.Equal(t, cas.isDefault, v.IsDefault()) }) } } func TestIntParam(t *testing.T) { var into int param := NewInt(&into, 0) cases := []struct { input string err bool result int string string }{ {"12", false, 12, "12"}, {"0", false, 0, "0"}, {"01", false, 1, "1"}, {"", true, 0, ""}, {"abc", true, 0, ""}, } for _, cas := range cases { t.Run(cas.input, func(t *testing.T) { t.Logf("testing with %q", cas.input) err := param.Set(cas.input) if cas.err { require.Errorf(t, err, "value %q should have returned an error", cas.input) return } require.Equal(t, cas.result, into) require.Equal(t, cas.string, param.String()) }) } var v flag.Value = NewInt(&into, 0) _, ok := v.(DefaultValued) require.False(t, ok, "*IntValue should not implement DefaultValued") } func TestFloat64Param(t *testing.T) { var into float64 param := NewFloat64(&into, 0) cases := []struct { input string err bool result float64 string string }{ {"12", false, 12, "12"}, {"0", false, 0, "0"}, {"01", false, 1, "1"}, {"3.14", false, 3.14, "3.14"}, {"00.123456789", false, 0.123456789, "0.123456789"}, {"", true, 0, ""}, {"abc", true, 0, ""}, } for _, cas := range cases { t.Run(cas.input, func(t *testing.T) { t.Logf("testing with %q", cas.input) err := param.Set(cas.input) if cas.err { require.Errorf(t, err, "value %q should have returned an error", cas.input) return } require.Equal(t, cas.result, into) require.Equal(t, cas.string, param.String()) }) } var v flag.Value = NewFloat64(&into, 0) _, ok := v.(DefaultValued) require.False(t, ok, "*IntValue should not implement DefaultValued") } func TestStringsParam(t *testing.T) { var into []string param := NewStrings(&into, nil) require.NoError(t, param.Set("a")) require.NoError(t, param.Set("b")) require.Equal(t, []string{"a", "b"}, into) require.Equal(t, `["a", "b"]`, param.String()) param.Clear() require.Empty(t, into) require.Equal(t, `[]`, param.String()) defCases := []struct { value []string isDefault bool }{ {value: nil, isDefault: true}, {value: []string{}, isDefault: true}, {value: []string{""}, isDefault: false}, {value: []string{"a"}, isDefault: false}, {value: []string{"a", "b"}, isDefault: false}, } for _, cas := range defCases { t.Run(fmt.Sprintf("%#v", cas.value), func(t *testing.T) { t.Logf("testing .IsDefault() with %v", cas.value) v := NewStrings(&into, cas.value) require.Equal(t, cas.isDefault, v.IsDefault()) }) } } func TestIntsParam(t *testing.T) { var into []int param := NewInts(&into, nil) err := param.Set("1") require.NoError(t, err) err = param.Set("2") require.NoError(t, err) require.Equal(t, []int{1, 2}, into) require.Equal(t, `[1, 2]`, param.String()) err = param.Set("c") require.Error(t, err) require.Equal(t, []int{1, 2}, into) param.Clear() require.Empty(t, into) require.Equal(t, `[]`, param.String()) defCases := []struct { value []int isDefault bool }{ {value: nil, isDefault: true}, {value: []int{}, isDefault: true}, {value: []int{0}, isDefault: false}, {value: []int{1}, isDefault: false}, {value: []int{1, 2}, isDefault: false}, } for _, cas := range defCases { t.Run(fmt.Sprintf("%#v", cas.value), func(t *testing.T) { t.Logf("testing .IsDefault() with %v", cas.value) v := NewInts(&into, cas.value) require.Equal(t, cas.isDefault, v.IsDefault()) }) } } func TestFloats64Param(t *testing.T) { var into []float64 param := NewFloats64(&into, nil) err := param.Set("1.1") require.NoError(t, err) err = param.Set("2.2") require.NoError(t, err) require.Equal(t, []float64{1.1, 2.2}, into) require.Equal(t, `[1.1, 2.2]`, param.String()) err = param.Set("c") require.Error(t, err) require.Equal(t, []float64{1.1, 2.2}, into) param.Clear() require.Empty(t, into) require.Equal(t, `[]`, param.String()) defCases := []struct { value []float64 isDefault bool }{ {value: nil, isDefault: true}, {value: []float64{}, isDefault: true}, {value: []float64{0}, isDefault: false}, {value: []float64{1}, isDefault: false}, {value: []float64{1, 2}, isDefault: false}, } for _, cas := range defCases { t.Run(fmt.Sprintf("%#v", cas.value), func(t *testing.T) { t.Logf("testing .IsDefault() with %v", cas.value) v := NewFloats64(&into, cas.value) require.Equal(t, cas.isDefault, v.IsDefault()) }) } } mow.cli-1.1.0/options.go000066400000000000000000000444341346511200500151110ustar00rootroot00000000000000package cli import ( "flag" "fmt" "strings" "github.com/jawher/mow.cli/internal/container" "github.com/jawher/mow.cli/internal/values" ) // BoolOpt describes a boolean option type BoolOpt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option EnvVar string // The option's initial value Value bool // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o BoolOpt) value(into *bool) (flag.Value, *bool) { if into == nil { into = new(bool) } return values.NewBool(into, o.Value), into } // StringOpt describes a string option type StringOpt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option EnvVar string // The option's initial value Value string // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o StringOpt) value(into *string) (flag.Value, *string) { if into == nil { into = new(string) } return values.NewString(into, o.Value), into } // IntOpt describes an int option type IntOpt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option EnvVar string // The option's initial value Value int // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o IntOpt) value(into *int) (flag.Value, *int) { if into == nil { into = new(int) } return values.NewInt(into, o.Value), into } // Float64Opt describes an float64 option type Float64Opt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option EnvVar string // The option's initial value Value float64 // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o Float64Opt) value(into *float64) (flag.Value, *float64) { if into == nil { into = new(float64) } return values.NewFloat64(into, o.Value), into } // StringsOpt describes a string slice option type StringsOpt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option. // The env variable should contain a comma separated list of values EnvVar string // The option's initial value Value []string // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o StringsOpt) value(into *[]string) (flag.Value, *[]string) { if into == nil { into = new([]string) } return values.NewStrings(into, o.Value), into } // IntsOpt describes an int slice option type IntsOpt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option. // The env variable should contain a comma separated list of values EnvVar string // The option's initial value Value []int // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o IntsOpt) value(into *[]int) (flag.Value, *[]int) { if into == nil { into = new([]int) } return values.NewInts(into, o.Value), into } // Floats64Opt describes an int slice option type Floats64Opt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option. // The env variable should contain a comma separated list of values EnvVar string // The option's initial value Value []float64 // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o Floats64Opt) value(into *[]float64) (flag.Value, *[]float64) { if into == nil { into = new([]float64) } return values.NewFloats64(into, o.Value), into } // VarOpt describes an option where the type and format of the value is controlled by the developer type VarOpt struct { // A space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. // The one letter names will then be called with a single dash (short option), the others with two (long options). Name string // The option description as will be shown in help messages Desc string // A space separated list of environment variables names to be used to initialize this option EnvVar string // A value implementing the flag.Value type (will hold the final value) Value flag.Value // A boolean to display or not the current value of the option in the help message HideValue bool // Set to true if this option was set by the user (as opposed to being set from env or not set at all) SetByUser *bool } func (o VarOpt) value() flag.Value { return o.Value } /* BoolOpt defines a boolean option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to a bool) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) BoolOpt(name string, value bool, desc string) *bool { return c.Bool(BoolOpt{ Name: name, Value: value, Desc: desc, }) } /* BoolOptPtr defines a bool option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) BoolOptPtr(into *bool, name string, value bool, desc string) { c.BoolPtr(into, BoolOpt{ Name: name, Value: value, Desc: desc, }) } /* StringOpt defines a string option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to a string) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringOpt(name string, value string, desc string) *string { return c.String(StringOpt{ Name: name, Value: value, Desc: desc, }) } /* StringOptPtr defines a string option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringOptPtr(into *string, name string, value string, desc string) { c.StringPtr(into, StringOpt{ Name: name, Value: value, Desc: desc, }) } /* IntOpt defines an int option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to an int) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntOpt(name string, value int, desc string) *int { return c.Int(IntOpt{ Name: name, Value: value, Desc: desc, }) } /* IntOptPtr defines a int option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to an int) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntOptPtr(into *int, name string, value int, desc string) { c.IntPtr(into, IntOpt{ Name: name, Value: value, Desc: desc, }) } /* Float64Opt defines an float64 option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to an float64) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Float64Opt(name string, value float64, desc string) *float64 { return c.Float64(Float64Opt{ Name: name, Value: value, Desc: desc, }) } /* Float64OptPtr defines a float64 option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to a float64) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Float64OptPtr(into *float64, name string, value float64, desc string) { c.Float64Ptr(into, Float64Opt{ Name: name, Value: value, Desc: desc, }) } /* StringsOpt defines a string slice option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to a string slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringsOpt(name string, value []string, desc string) *[]string { return c.Strings(StringsOpt{ Name: name, Value: value, Desc: desc, }) } /* StringsOptPtr defines a string slice option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) StringsOptPtr(into *[]string, name string, value []string, desc string) { c.StringsPtr(into, StringsOpt{ Name: name, Value: value, Desc: desc, }) } /* IntsOpt defines an int slice option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to an int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntsOpt(name string, value []int, desc string) *[]int { return c.Ints(IntsOpt{ Name: name, Value: value, Desc: desc, }) } /* IntsOptPtr defines a int slice option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) IntsOptPtr(into *[]int, name string, value []int, desc string) { c.IntsPtr(into, IntsOpt{ Name: name, Value: value, Desc: desc, }) } /* Floats64Opt defines an float64 slice option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result should be stored in a variable (a pointer to an float64 slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Floats64Opt(name string, value []float64, desc string) *[]float64 { return c.Floats64(Floats64Opt{ Name: name, Value: value, Desc: desc, }) } /* Floats64OptPtr defines a int slice option on the command c named `name`, with an initial value of `value` and a description of `desc` which will be used in help messages. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The into parameter points to a variable (a pointer to a int slice) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) Floats64OptPtr(into *[]float64, name string, value []float64, desc string) { c.Floats64Ptr(into, Floats64Opt{ Name: name, Value: value, Desc: desc, }) } /* VarOpt defines an option where the type and format is controlled by the developer. The name is a space separated list of the option names *WITHOUT* the dashes, e.g. `f force` and *NOT* `-f --force`. The one letter names will then be called with a single dash (short option), the others with two (long options). The result will be stored in the value parameter (a value implementing the flag.Value interface) which will be populated when the app is run and the call arguments get parsed */ func (c *Cmd) VarOpt(name string, value flag.Value, desc string) { c.mkOpt(container.Container{Name: name, Desc: desc, Value: value}) } func mkOptStrs(optName string) []string { res := strings.Fields(optName) for i, name := range res { prefix := "-" if len(name) > 1 { prefix = "--" } res[i] = prefix + name } return res } func (c *Cmd) mkOpt(opt container.Container) { opt.ValueSetFromEnv = values.SetFromEnv(opt.Value, opt.EnvVar) opt.Names = mkOptStrs(opt.Name) c.options = append(c.options, &opt) for _, name := range opt.Names { if _, found := c.optionsIdx[name]; found { panic(fmt.Sprintf("duplicate option name %q", name)) } c.optionsIdx[name] = &opt } } mow.cli-1.1.0/testdata/000077500000000000000000000000001346511200500146675ustar00rootroot00000000000000mow.cli-1.1.0/testdata/help-output.txt000066400000000000000000000035011346511200500177150ustar00rootroot00000000000000 Usage: app [-bdsuikqs] BOOL1 [STR1] INT3... COMMAND [arg...] App Desc Arguments: BOOL1 Bool Argument 1 (env $BOOL1) BOOL2 Bool Argument 2 (default true) BOOL3 Bool Argument 3 (env $BOOL3) STR1 String Argument 1 (env $STR1) STR2 String Argument 2 (env $STR2) (default "a value") STR3 String Argument 3 (env $STR3) INT1 Int Argument 1 (env $INT1) (default 0) INT2 Int Argument 2 (env $INT2) (default 1) INT3 Int Argument 3 (env $INT3) STRS1 Strings Argument 1 (env $STRS1) STRS2 (env $STRS2) (default ["value1", "value2"]) STRS3 Strings Argument 3 (env $STRS3) INTS1 Ints Argument 1 (env $INTS1) INTS2 Ints Argument 2 (env $INTS2) (default [1, 2, 3]) INTS3 Ints Argument 3 (env $INTS3) Options: -b, --bool1 Bool Option 1 (env $BOOL1) --bool2 Bool Option 2 (default true) -d Bool Option 3 (env $BOOL3) -s, --str1 String Option 1 (env $STR1) --str2 String Option 2 (default "a value") -v String Option 3 (env $STR3) -i, --int1 (env $INT1, $ALIAS_INT1) (default 0) --int2 Int Option 2 (env $INT2) (default 1) -k Int Option 3 (env $INT3) -x, --strs1 Strings Option 1 (env $STRS1) --strs2 Strings Option 2 (env $STRS2) (default ["value1", "value2"]) -z Strings Option 3 (env $STRS3) -q, --ints1 Ints Option 1 (env $INTS1) --ints2 Ints Option 2 (env $INTS2) (default [1, 2, 3]) -j Ints Option 3 (env $INTS3) Commands: command1 command1 description command2 command2 description command3 command3 description Run 'app COMMAND --help' for more information on a command. mow.cli-1.1.0/testdata/long-help-output.txt000066400000000000000000000002241346511200500206510ustar00rootroot00000000000000 Usage: app [-o] ARG Longer App Desc Arguments: ARG Argument Options: -o, --opt Option mow.cli-1.1.0/testdata/multi-line-desc-help-output.txt000066400000000000000000000006471346511200500227160ustar00rootroot00000000000000 Usage: app [-o] ARG Longer App Desc Arguments: ARG Argument Description Multiple Lines Options: -o, --opt Option does something another line (env $XXX_TEST) (default "default") -f, --force Force does something another line (env $YYY_TEST) mow.cli-1.1.0/var_test.go000066400000000000000000000056731346511200500152470ustar00rootroot00000000000000package cli import ( "fmt" "testing" "time" "os" "github.com/stretchr/testify/require" ) // Counter type Counter int func (d *Counter) Set(v string) error { *d++ return nil } func (d *Counter) String() string { return fmt.Sprintf("%d", *d) } func (d *Counter) IsBoolFlag() bool { return true } // Duration type Duration time.Duration func (d *Duration) Set(v string) error { parsed, err := time.ParseDuration(v) if err != nil { return err } *d = Duration(parsed) return nil } func (d *Duration) String() string { duration := time.Duration(*d) return duration.String() } type Percent []float64 func parsePercent(v string) (float64, error) { var d int _, err := fmt.Sscanf(v, "%d%%", &d) if err != nil { return 0, err } return float64(d) / 100, nil } func (p *Percent) Set(v string) error { f, err := parsePercent(v) if err != nil { return err } *p = append(*p, f) return nil } func (p *Percent) Clear() { *p = nil } func (p *Percent) String() string { res := "[" for idx, p := range *p { if idx > 0 { res += ", " } res += fmt.Sprintf("%.0f%%", p*100) } return res + "]" } func TestVar(t *testing.T) { value := Counter(0) duration := Duration(0) percents := Percent{} app := App("var", "") app.Spec = "-v... DURATION PERCENT..." app.VarOpt("v", &value, "") app.VarArg("DURATION", &duration, "") app.VarArg("PERCENT", &percents, "") ex := false app.Action = func() { ex = true } require.NoError(t, app.Run([]string{"cp", "-vvv", "1h", "10%", "5%"})) require.Equal(t, Counter(3), value) require.Equal(t, Duration(1*time.Hour), duration) require.Equal(t, Percent([]float64{0.1, 0.05}), percents) require.True(t, ex, "Exec wasn't called") } func TestVarFromEnv(t *testing.T) { os.Setenv("MOWCLI_DURATION", "1h2m3s") os.Setenv("MOWCLI_ARG_PERCENTS", "25%, 1%") os.Setenv("MOWCLI_OPT_PERCENTS", "90%, 42%") duration := Duration(0) argPercents := Percent{} optPercents := Percent{} app := App("var", "") app.Spec = "-p... DURATION PERCENT..." app.Var(VarArg{ Name: "DURATION", Value: &duration, EnvVar: "MOWCLI_DURATION", }) app.Var(VarArg{ Name: "PERCENT", Value: &argPercents, EnvVar: "MOWCLI_ARG_PERCENTS", }) app.Var(VarOpt{ Name: "p", Value: &optPercents, EnvVar: "MOWCLI_OPT_PERCENTS", }) require.Equal(t, Duration(1*time.Hour+2*time.Minute+3*time.Second), duration) require.Equal(t, Percent([]float64{0.25, 0.01}), argPercents) require.Equal(t, Percent([]float64{0.9, 0.42}), optPercents) } func TestVarOverrideEnv(t *testing.T) { os.Setenv("MOWCLI_PERCENTS", "25%, 1%") percents := Percent{} app := App("var", "") app.Spec = "PERCENT..." app.Var(VarArg{ Name: "PERCENT", Value: &percents, EnvVar: "MOWCLI_PERCENTS", }) ex := false app.Action = func() { ex = true require.Equal(t, Percent([]float64{0, 0.99}), percents) } require.NoError(t, app.Run([]string{"var", "0%", "99%"})) require.True(t, ex, "Action should have been called") }