This fixes the newline that gets appended within the range in the subcommands template. The reason for this is it makes the CLI UI a little inconsistent with the Commands: help text not having a newline at the beginning or at the end of the All other commands: piece of the help text in Terraform. It also just looks better, IMHO. :)

Filing this for https://github.com/hashicorp/terraform/issues/1773

Current behavior: Except for help/version, flags before a subcommand are silently ignored.

Possible solutions:

(A) Flags before subcommand cause error (B) Flags before subcommand are passed in as subcommand args

Unsure what the better behavior. Originally I thought (A) but then I swung to (B) after staring at it a bit.

Thoughts?

This fixes an issue where multiple subcommands are nested, but the user is requesting help for a deeply nested command.

It's strange that the tests specifically tested the opposite of this behavior, so I'm not sure if this is right @mitchellh

There isn't currently a way to mark a subcommand as "hidden". It's possible to filter help output to exclude it using a HelpFunc, but the subcommand still appears in the autocompletion. There should either be a way to customize the list of commands which are auto-completed or (better), a first-class mechanism for marking a command as hidden.

There are a few use cases here, the most prominent being backwards compatibility. I may want to introduce a new command to do something, but I want to have the old command around with a warning for a few releases.

Another use case involves hidden "internal-only" commands. Sometimes you want some flags or commands that are for internal use only. Again, there's currently no way to achieve this nicely.

/cc @dadgar

With Golang 1.6 TestCLIRun_printCommandHelpSubcommands sometimes fail as follows:

--- FAIL: TestCLIRun_printCommandHelpSubcommands (0.00s) 
        cli_test.go:344: bad: []string{"-h", "foo"} 

                '"donuts\n\nSubcommands:\n\n    longer    hi!\n    bar       hi!\n\n"' 

                '"donuts\n\nSubcommands:\n\n    bar       hi!\n    longer    hi!\n\n"' 

Instead of Ui.Error(string) it should be Ui.Error(string, interface{}...). This should then call fmt.Fprintf(w, string, ...v).

Almost all of my calls to Ui.(Error|Info|Output) end up including a call to fmt.Sprintf.

Fixes #65

This introduces a new optional interface CommandHidden. When implemented, the result of Hidden() allows a command to declare itself as hidden or not. A hidden command does not show up in the help callback map or for command autocompletion.

This doesn't affect flags at all. In the future when we take a look at flags more holistically, we should consider allowing flags to declare themselves hidden as well. However, this PR doesn't affect that in any way.

Adds the Print() function to the Ui Interface. Print takes a message string, and Prints it to the UI without appending a newline character to the end of the message.

This allows for multiple calls to Print() to write output to the same line of the writer.

Now, {command} --help and {command} --version returns exit status 1. For example,

$ ./bin/packer --help
...
$ echo $?
1
$ ./bin/packer --version
0.8.7
$ echo $?
1

These are normal cases, thus exit status 0 is better I think. This PR changes the behavior as follows.

$ ./bin/packer --help
...
$ echo $?
0
$ ./bin/packer --version
0.8.7
$ echo $?
0

Could you check it?

$ go version
go version go1.4.2 solaris/amd64
$ go build github.com/mitchellh/cli 
# github.com/mitchellh/cli
src/github.com/mitchellh/cli/ui.go:79: undefined: terminal.IsTerminal
src/github.com/mitchellh/cli/ui.go:81: undefined: terminal.ReadPassword

I ran into a situation where I needed my program to just launch something with no subcommand, but also have a set of subcommands to interact with data and a running daemon. All bases should be covered here (tests, help text, etc...).

Noticed this behavior on an internal tool, essentially, if you have flags defined for a command, then execute a subcommand of that command with a flag before the subcommand, then it identifies the command as the subcommand.

For example, if we take the test cases @ https://github.com/mitchellh/cli/blob/master/cli_test.go#L1459-L1489 and change it to:

func TestCLISubcommand_nested(t *testing.T) {
	testCases := []struct {
		args       []string
		subcommand string
	}{
		{[]string{"bar"}, "bar"},
		{[]string{"foo", "-h"}, "foo"},
		{[]string{"-h", "bar"}, "bar"},
		{[]string{"foo", "bar", "-h"}, "foo bar"},
		{[]string{"foo", "bar", "baz", "-h"}, "foo bar baz"},
		{[]string{"foo", "bar", "-h", "baz"}, "foo bar"}, // expected match would be `foo bar baz`
		{[]string{"-h", "foo", "bar"}, "foo bar"},
	}

	for _, testCase := range testCases {
		cli := &CLI{
			Args: testCase.args,
			Commands: map[string]CommandFactory{
				"foo bar": func() (Command, error) {
					return new(MockCommand), nil
				},
				"foo bar baz": func() (Command, error) {
					return new(MockCommand), nil
				},
			},
		}
		result := cli.Subcommand()

		if result != testCase.subcommand {
			t.Errorf("Expected %#v, got %#v. Args: %#v",
				testCase.subcommand, result, testCase.args)
		}
	}
}

I guess the question is, with other tools like cobra which handle flags anywhere within the arguments, does it make sense to change this library's behavior?

For example the following is a zsh completion function for command foo:

#compdef _foo foo
compadd first second third fourth

So, if we type foo <tab> in the zsh terminal, it suggests first second third fourth.

How can I do this using cli?

Complete v2 includes some improvements, but I mostly perform this PR because it introduced breaking changes which breaks clients of this library which are not yet able to use go modules. If this change won't be accepted I will revert the changes in the complete library.

• This makes the prompts easier to test, e.g., if we ask for both username and password, we can now simply do printf "myName\nmyPassword\n" | myCli.

• We don't create a new bufio.Reader each tiem we ask, hopefully it doesn't break someone's program.

• All the tests pass! :)