cmd/cue: drop support for the deprecated short form of cue cmd

`cue foo` used to be a shortcut for `cue cmd foo`,
but was deprecated in v0.9.0 following https://cuelang.org/issue/2519.

The shortcut introduced a number of problems:
* The root `cue` command needed to be significantly more complex;
  it had to know how to correctly capture flags and arguments for
  `cue cmd` and pass them along to the subcommand.
* Spelling mistakes like `cue evla` instead of `cue eval` could easily
  result in running arbitrary code if _tool.cue files existed.
* In some edge cases we would have to load _tool.cue files outside of
  `cue cmd` to make sure the user wasn't trying to use a tool command.
  This also caused confusing error messages, such as the `cue evla` typo
  resulting in a suggestion to declare the command in a _tool.cue file.

The issues above existed so the user could save typing four characters,
which doesn't seem worth it. We now only support `cue cmd foo`,
which is more explicit and consistent.

One test case which covered running a command in "short" code now fails.
Two others which only tested fixed bugs in the short form are deleted,
as those edge cases are completely gone now.

Fixes #2519.

Signed-off-by: Daniel Martí <[email protected]>
Change-Id: I1d80622f6db3fd0f0fb7494356e5360697b048be
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1199634
TryBot-Result: CUEcueckoo <[email protected]>
Reviewed-by: Matthew Sackman <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: mvdan

cmd/cue/cmd/cmd.go

@@ -19,7 +19,6 @@ import (
 
 	"cuelang.org/go/cue/errors"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // TODO: generate long description from documentation.
@@ -135,48 +134,26 @@ again).
 Run "cue help commands" for more details on tasks and workflow commands.
 `,
 		RunE: mkRunE(c, func(cmd *Command, args []string) error {
-			// The behavior when there's no known subcommand is different
-			// depending on whether we ran via `cue cmd` or the `cue` shortcut.
-			isRootCmd := cmd.Command == cmd.root
-
 			if len(args) == 0 {
-				// `cue` should print the top-level help like `cue -h`,
-				// but `cue cmd` should explain that a custom command is required.
-				if isRootCmd {
-					return pflag.ErrHelp
-				}
 				w := cmd.OutOrStderr()
 				fmt.Fprintln(w, "cmd must be run as one of its subcommands")
 				fmt.Fprintln(w, "Run 'cue help cmd' for known subcommands.")
 				return ErrPrintedError
 			}
 			tools, err := buildTools(cmd, args[1:])
-			if err != nil && !isRootCmd {
-				// `cue cmd` fails immediately if there is no CUE package,
-				// but `cue` does not in order to always show a useful error in `cue typo`.
+			if err != nil {
 				return err
 			}
 			sub, err := customCommand(cmd, commandSection, args[0], tools)
 			if err != nil {
 				w := cmd.OutOrStderr()
-				cmdline := "cue"
-				if !isRootCmd {
-					cmdline += " cmd"
-				}
 				fmt.Fprint(w, errors.Details(err, &errors.Config{Cwd: rootWorkingDir}))
 				fmt.Fprintln(w, `Ensure custom commands are defined in a "_tool.cue" file.`)
 				fmt.Fprintln(w, "Run 'cue help cmd' to list available custom commands.")
-				if isRootCmd {
-					fmt.Fprintln(w, "Run 'cue help' to see the built-in 'cue' commands.")
-				}
 				return ErrPrintedError
 			}
 			// Presumably the *cobra.Command argument should be cmd.Command,
 			// as that is the one which will have the right settings applied.
-			if isRootCmd {
-				cmd.PrintErrf("The short-form 'cue %[1]s' is deprecated; use 'cue cmd %[1]s'.\n", args[0])
-				cmd.PrintErrf("See: https://cuelang.org/issue/2519\n")
-			}
 			return sub.RunE(cmd.Command, args[1:])
 		}),
 	}

cmd/cue/cmd/common.go

@@ -385,7 +385,7 @@ func newBuildPlan(cmd *Command, cfg *config) (p *buildPlan, err error) {
 	}
 	cfg.reFile = re
 
-	setTags(cfg.loadCfg, cmd.Flags(), cmd.Parent().Flags())
+	setTags(cfg.loadCfg, cmd.Flags())
 
 	return p, nil
 }
@@ -394,16 +394,11 @@ func (p *buildPlan) matchFile(file string) bool {
 	return p.cfg.reFile.MatchString(file)
 }
 
-func setTags(cfg *load.Config, flags ...*pflag.FlagSet) {
-	// setTags usually receives a subcommmand's flags, plus the parent (root) command's flags,
-	// so that we can support "cue cmd -t foo=bar mycmd" as well as the short form "cue -t foo=bar mycmd".
-	// TODO: once we remove "cue cmd" short-hand support, go back to a single FlagSet parameter.
-	for _, f := range flags {
-		tags, _ := f.GetStringArray(string(flagInject))
-		cfg.Tags = append(cfg.Tags, tags...)
-		if b, _ := f.GetBool(string(flagInjectVars)); b {
-			cfg.TagVars = load.DefaultTagVars()
-		}
+func setTags(cfg *load.Config, flags *pflag.FlagSet) {
+	tags, _ := flags.GetStringArray(string(flagInject))
+	cfg.Tags = append(cfg.Tags, tags...)
+	if b, _ := flags.GetBool(string(flagInjectVars)); b {
+		cfg.TagVars = load.DefaultTagVars()
 	}
 }
 
@@ -780,8 +775,7 @@ func buildTools(cmd *Command, args []string) (*cue.Instance, error) {
 	}
 	loadCfg := *cfg.loadCfg
 	loadCfg.Tools = true
-	f := cmd.cmd.Flags()
-	setTags(&loadCfg, f, cmd.cmd.Parent().Flags())
+	setTags(&loadCfg, cmd.cmdCmd.Flags())
 
 	binst := loadFromArgs(args, &loadCfg)
 	if len(binst) == 0 {

cmd/cue/cmd/root.go

@@ -190,11 +190,6 @@ func New(args []string) (*Command, error) {
 		// TODO: the short help text below seems to refer to `cue cmd`, like helpTemplate.
 		Short: "cue emits configuration files to user-defined commands.",
 
-		// ArbitraryArgs allows us to forward the top-level RunE to cmdCmd.RunE,
-		// which supports `cue mycmd` as a short-cut for `cue cmd mycmd`.
-		// Without ArbitraryArgs, cobra fails with "unknown command" errors.
-		Args: cobra.ArbitraryArgs,
-
 		// We print errors ourselves in Main, which allows for ErrPrintedError.
 		// Similarly, we don't want to print the entire help text on any error.
 		// We can explicitly trigger help on certain errors via pflag.ErrHelp.
@@ -203,6 +198,7 @@ func New(args []string) (*Command, error) {
 
 		// We currently support top-level custom commands like `cue mycmd` as an alias
 		// for `cue cmd mycmd`, so any sub-command suggestions might be confusing.
+		// TODO(mvdan): remove this and test it, as we no longer support `cue mycmd`.
 		DisableSuggestions: true,
 	}
 
@@ -214,14 +210,9 @@ func New(args []string) (*Command, error) {
 		root:    cmd,
 		ctx:     cuecontext.New(rootContextOptions...),
 	}
-
-	cmdCmd := newCmdCmd(c)
-	c.cmd = cmdCmd
+	c.cmdCmd = newCmdCmd(c)
 
 	addGlobalFlags(cmd.PersistentFlags())
-	// We add the injection flags to the root command for the sake of the short form "cue -t foo=bar mycmd".
-	// Note that they are not persistent, so that they aren't inherited by sub-commands like "cue fmt".
-	addInjectionFlags(cmd.Flags(), false, true)
 
 	// Cobra's --help flag shows up in help text by default, which is unnecessary.
 	cmd.InitDefaultHelpFlag()
@@ -240,7 +231,7 @@ func New(args []string) (*Command, error) {
 	cmd.SetHelpTemplate(helpTemplate)
 
 	for _, sub := range []*cobra.Command{
-		cmdCmd,
+		c.cmdCmd,
 		newCompletionCmd(c),
 		newEvalCmd(c),
 		newDefCmd(c),
@@ -261,9 +252,6 @@ func New(args []string) (*Command, error) {
 		cmd.AddCommand(sub)
 	}
 
-	// For `cue mycmd` to be a shortcut for `cue cmd mycmd`.
-	cmd.RunE = cmdCmd.RunE
-
 	cmd.SetArgs(args)
 	return c, nil
 }
@@ -303,8 +291,8 @@ type Command struct {
 
 	root *cobra.Command
 
-	// Subcommands
-	cmd *cobra.Command
+	// _tool.cue subcommands.
+	cmdCmd *cobra.Command
 
 	ctx *cue.Context
 

cmd/cue/cmd/testdata/script/cmd_notool2.txtar

@@ -2,13 +2,11 @@ exec cue cmd hello
 stdout 'Hello world!'
 ! stderr .
 
-exec cue hello
-stdout 'Hello world!'
-cmp stderr stderr-warning
+! exec cue hello
+cmp stderr short-stderr
 
--- stderr-warning --
-The short-form 'cue hello' is deprecated; use 'cue cmd hello'.
-See: https://cuelang.org/issue/2519
+-- short-stderr --
+unknown command "hello" for "cue"
 -- task_tool.cue --
 package home
 

cmd/cue/cmd/testdata/script/cmd_short.txtar

@@ -1,11 +1,6 @@
 exec cue cmd -t prod -t name=bar tag tags.cue tags_tool.cue
 cmp stdout expect-stdout
 
-# Same as before, but now with the short form.
-# See https://cuelang.org/issue/2510.
-exec cue -t prod -t name=bar tag tags.cue tags_tool.cue
-cmp stdout expect-stdout
-
 # Verify that the new global -t flag added as a fix for issue 2510 above
 # works with the explicit or implicit "cmd" sub-command,
 # but not with other sub-commands like "fmt".

cmd/cue/cmd/testdata/script/cmd_tags.txtar

@@ -35,9 +35,7 @@ stdout -count=1 '^The cue tools supports the following file types:$'
 
 ! exec cue filetypes
 ! stdout .
-stderr -count=1 '^no commands defined'
-# TODO(mvdan): once `cue somecmd` is phased out, we can give a better error message here.
-# stderr -count=1 '^unknown command'
+stderr -count=1 '^unknown command'
 
 # Requesting help for missing commands and sub-commands fails and prints the help text.
 

cmd/cue/cmd/testdata/script/help.txtar

@@ -7,9 +7,6 @@ cmp stderr unknown_cmd.out
 cmp stderr unknown_flag.out
 
 -- unknown_cmd.out --
-no commands defined
-Ensure custom commands are defined in a "_tool.cue" file.
-Run 'cue help cmd' to list available custom commands.
-Run 'cue help' to see the built-in 'cue' commands.
+unknown command "unknown" for "cue"
 -- unknown_flag.out --
 unknown flag: --unknown