help: reimplemented help subsystem

In order to simplify help implementation:
- main help command is implemented in a way similar to the other
  commands (internal/external variation of help command is handled with
  the common handler cmd.RunModuleFunc)
- help for every external command is tied to a command itself over
  cmd.SetHelp rather than add separate help subcommand to the main help
  command (it allows to get help uniformly for internal and external
  commands)
- corresponding Cobra commands are created for all available external
  commands rather than only for the invoked one (it is needed for the
  uniform handling mentioned above)

In addition:
- completion for help command is improved (also suggested/completed
  subcommands, if any)
- external commands are also implemented over the common handler
  cmd.RunModuleFunc to reduce code duplication

Close #1136

Author: elhimov

cli/cmd/external.go

@@ -1,19 +1,16 @@
 package cmd
 
 import (
-	"strings"
-
-	"github.com/apex/log"
 	"github.com/spf13/cobra"
 	"github.com/tarantool/tt/cli/modules"
-	"github.com/tarantool/tt/cli/util"
+	"golang.org/x/exp/slices"
 )
 
 // ExternalCmd configures external commands.
-func configureExternalCmd(rootCmd *cobra.Command,
-	modulesInfo *modules.ModulesInfo, forceInternal bool, args []string) {
+func configureExternalCmd(rootCmd *cobra.Command, modulesInfo *modules.ModulesInfo,
+	forceInternal bool) {
 	configureExistsCmd(rootCmd, modulesInfo, forceInternal)
-	configureNonExistentCmd(rootCmd, modulesInfo, args)
+	configureNonExistentCmd(rootCmd, modulesInfo)
 }
 
 // configureExistsCmd configures an external commands
@@ -29,54 +26,33 @@ func configureExistsCmd(rootCmd *cobra.Command, modulesInfo *modules.ModulesInfo
 
 // configureNonExistentCmd configures an external command that
 // has no internal implementation within the Tarantool CLI.
-func configureNonExistentCmd(rootCmd *cobra.Command,
-	modulesInfo *modules.ModulesInfo, args []string) {
-	// Since the user can pass flags, to determine the name of
-	// an external command we have to take the first non-flag argument.
-	externalCmd := args[0]
-	for _, name := range args {
-		if !strings.HasPrefix(name, "-") && name != "help" {
-			externalCmd = name
-			break
-		}
-	}
-
+func configureNonExistentCmd(rootCmd *cobra.Command, modulesInfo *modules.ModulesInfo) {
 	// We avoid overwriting existing commands - we should add a command only
 	// if it doesn't have an internal implementation in Tarantool CLI.
+	// So first collect list of internal command names.
+	internalCmdNames := []string{"help"}
 	for _, cmd := range rootCmd.Commands() {
-		if cmd.Name() == externalCmd {
-			return
-		}
+		internalCmdNames = append(internalCmdNames, cmd.Name())
 	}
 
-	helpCmd := util.GetHelpCommand(rootCmd)
-	externalCmdPath := rootCmd.Name() + " " + externalCmd
-	if _, found := (*modulesInfo)[externalCmdPath]; found {
-		rootCmd.AddCommand(newExternalCommand(modulesInfo, externalCmd,
-			externalCmdPath, nil))
-		helpCmd.AddCommand(newExternalCommand(modulesInfo, externalCmd, externalCmdPath,
-			[]string{"--help"}))
+	// Add external command only if it doesn't have an internal implementation in Tarantool CLI.
+	for _, manifest := range *modulesInfo {
+		if !slices.Contains(internalCmdNames, manifest.Name) {
+			rootCmd.AddCommand(newExternalCmd(manifest))
+		}
 	}
 }
 
-// newExternalCommand returns a pointer to a new external
+// newExternalCmd returns a pointer to a new external
 // command that will call modules.RunCmd.
-func newExternalCommand(modulesInfo *modules.ModulesInfo,
-	cmdName, cmdPath string, addArgs []string) *cobra.Command {
-	cmd := &cobra.Command{
-		Use: cmdName,
-		Run: func(cmd *cobra.Command, args []string) {
-			if addArgs != nil {
-				args = append(args, addArgs...)
-			}
-
-			cmdCtx.Cli.ForceInternal = false
-			if err := modules.RunCmd(&cmdCtx, cmdPath, modulesInfo, nil, args); err != nil {
-				log.Fatalf(err.Error())
-			}
-		},
+func newExternalCmd(manifest modules.Manifest) *cobra.Command {
+	var cmd = &cobra.Command{
+		Use:                manifest.Name,
+		Run:                RunModuleFunc(nil),
+		DisableFlagParsing: true,
 	}
-
-	cmd.DisableFlagParsing = true
+	cmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
+		cmd.Print(manifest.Help)
+	})
 	return cmd
 }

cli/cmd/help.go

@@ -2,83 +2,59 @@ package cmd
 
 import (
 	"fmt"
-	"os"
 	"strings"
 
-	"github.com/apex/log"
 	"github.com/spf13/cobra"
 	"github.com/tarantool/tt/cli/cmdcontext"
 	"github.com/tarantool/tt/cli/modules"
 	"github.com/tarantool/tt/cli/util"
 )
 
-// DefaultHelpFunc is a type of the standard built-in
-// cobra implementation of the help function.
-type DefaultHelpFunc func(*cobra.Command, []string)
-
-// configureHelpCommand configures our own help module
-// so that it can be external as well.
-// If the help is called for an external module
-// (for example `tt help version`), we try to get the help from it.
-func configureHelpCommand(cmdCtx *cmdcontext.CmdCtx, rootCmd *cobra.Command) error {
+func configureHelpCommand(rootCmd *cobra.Command, modulesInfo *modules.ModulesInfo) error {
 	// Add information about external modules into help template.
-	rootCmd.SetUsageTemplate(fmt.Sprintf(usageTemplate, getExternalCommandsString(&modulesInfo)))
-	defaultHelp := rootCmd.HelpFunc()
-
-	rootCmd.SetHelpFunc(func(cmd *cobra.Command, args []string) {
-		cmdCtx.CommandName = cmd.Name()
-		if len(os.Args) == 1 || util.Find(args, "-h") != -1 || util.Find(args, "--help") != -1 {
-			defaultHelp(cmd, nil)
-			return
-		}
+	rootCmd.SetUsageTemplate(fmt.Sprintf(usageTemplate, getExternalCommandsString(modulesInfo)))
 
-		args = modules.GetDefaultCmdArgs("help")
-		err := modules.RunCmd(cmdCtx, "tt help", &modulesInfo,
-			getInternalHelpFunc(cmd, defaultHelp), args)
+	internalHelpModule := func(cmdCtx *cmdcontext.CmdCtx, args []string) error {
+		cmd, _, err := rootCmd.Find(args)
 		if err != nil {
-			log.Fatalf(err.Error())
+			return err
 		}
-	})
-
-	// Add valid arguments for completion.
-	helpCmd := util.GetHelpCommand(rootCmd)
-	for name := range modulesInfo {
-		helpCmd.ValidArgs = append(helpCmd.ValidArgs, name)
+		cmd.Help()
+		return nil
 	}
 
-	return nil
-}
-
-// getInternalHelpFunc returns a internal implementation of help module.
-func getInternalHelpFunc(cmd *cobra.Command, help DefaultHelpFunc) modules.InternalFunc {
-	return func(cmdCtx *cmdcontext.CmdCtx, args []string) error {
-		switch manifest, found := modulesInfo[cmd.CommandPath()]; {
-		// Cases when we have to run the "default" help:
-		// - `tt help` and no external help module.
-		// 	It looks strange: if we type the command `tt help`,
-		// 	the call to cmd.Name() returns `tt` and I don’t know
-		// 	what is the reason. If there is an external help module,
-		// 	then we also cannot be here (see the code below) and it
-		// 	is enough to check cmd.Name() == "tt".
-		// - `tt help -I`
-		// - `tt --help`, `tt -h` or `tt` (look code above).
-		case cmd.Name() == "tt", !found:
-			help(cmd, nil)
-		// We make a call to the external module (if it exists) with the `--help` flag.
-		default:
-			helpMsg, err := modules.GetExternalModuleHelp(manifest.Main)
-			if err != nil {
-				return err
+	helpCmd := &cobra.Command{
+		Use:   "help [command]",
+		Short: "Help about any command",
+		Run:   RunModuleFunc(internalHelpModule),
+		ValidArgsFunction: func(c *cobra.Command, args []string, toComplete string) (
+			[]string, cobra.ShellCompDirective) {
+			var completions []string
+			cmd, _, e := c.Root().Find(args)
+			if e != nil {
+				return nil, cobra.ShellCompDirectiveNoFileComp
 			}
-
-			cmd.Print(helpMsg)
-		}
-
-		return nil
+			if cmd == nil {
+				// Root help command.
+				cmd = c.Root()
+			}
+			for _, subCmd := range cmd.Commands() {
+				// if subCmd.IsAvailableCommand() || subCmd == cmd.helpCommand {
+				if subCmd.IsAvailableCommand() {
+					if strings.HasPrefix(subCmd.Name(), toComplete) {
+						completions = append(completions, fmt.Sprintf("%s\t%s", subCmd.Name(), subCmd.Short))
+					}
+				}
+			}
+			return completions, cobra.ShellCompDirectiveNoFileComp
+		},
 	}
+
+	rootCmd.SetHelpCommand(helpCmd)
+	return nil
 }
 
-// getExternalCommandsString returns a pretty string
+// getExternalCommandString returns a pretty string
 // of descriptions for external modules.
 func getExternalCommandsString(modulesInfo *modules.ModulesInfo) string {
 	str := ""

cli/cmd/root.go

@@ -228,7 +228,6 @@ After that tt will be able to manage the application using 'replicaset_example'
 
 	// Setup decoration for Command's error messages.
 	rootCmd.SetErr(&logErrorWriterDecorator{rootCmd.ErrOrStderr(), logHandler})
-	rootCmd.InitDefaultHelpCmd()
 
 	return rootCmd
 }
@@ -314,12 +313,10 @@ func InitRoot() {
 
 	// External commands must be configured in a special way.
 	// This is necessary, for example, so that we can pass arguments to these commands.
-	if len(os.Args) > 1 {
-		configureExternalCmd(rootCmd, &modulesInfo, cmdCtx.Cli.ForceInternal, os.Args[1:])
-	}
+	configureExternalCmd(rootCmd, &modulesInfo, cmdCtx.Cli.ForceInternal)
 
 	// Configure help command.
-	err = configureHelpCommand(&cmdCtx, rootCmd)
+	err = configureHelpCommand(rootCmd, &modulesInfo)
 	if err != nil {
 		log.Fatalf("Failed to set up help command: %s", err)
 	}