Flatten cmd/ constructors for sub-commands

[na--]

Now that #2410 and #2412 introduce a unified way of constructing *cobra.Command sub-commands:

k6/cmd/root.go

Lines 242 to 246 in e4241ca

	rootCmd.AddCommand(
	getArchiveCmd(gs), getCloudCmd(gs), getConvertCmd(gs), getInspectCmd(gs),
	loginCmd, getPauseCmd(gs), getResumeCmd(gs), getScaleCmd(gs), getRunCmd(gs),
	getStatsCmd(gs), getStatusCmd(gs), getVersionCmd(gs),
	)

Instead of having functions that are hundreds of lines of code and starting indented 3 levels deep:

k6/cmd/run.go

Lines 80 to 83 in e4241ca

	RunE: func(cmd *cobra.Command, args []string) error {
	printBanner(globalState)
	test, err := loadTest(globalState, cmd, args, getConfig)

We can introduce custom helper types for some of the bigger sub-commands (e.g. k6 run, k6 cloud, etc.) that split apart these monstrosities and flatten then 🎉 Something like this:

func getCmdRun(gs *globalState) *cobra.Command {
    c := &cmdRun{gs}

    cmd := &cobra.Command{
        Use:   "run",
        // ...
        RunE: c.run,
    }
    cmd.Flags().SortFlags = false
    cmd.Flags().AddFlagSet(c.flagSet())

    return cmd
}

type cmdRun struct {
    gs *globalState
}

func (c *cmdRun) run(cmd *cobra.Command, args []string) error {
    printBanner(c.gs)

    test, err := loadTest(c.gs, cmd, args, getPartialConfig)
    if err != nil {
        return err
    }

    // ...
    // rest of the code, potentially split apart in multiple cmdRun methods
    // ...
}

func (c *cmdRun) flagSet() *pflag.FlagSet {
    // ...
}

Tons of benefits:

• no unnecessary indentation
• can split apart huge functions nicely
• every sub-command struct can hold state, if needs be
• it can also have properties for the per-command flags like these, so they are not loose variables in a quasi-global scope:
  

  k6/cmd/archive.go

  Line 29 in e4241ca

  archiveOut := "archive.tar"

  
  

  k6/cmd/cloud.go

  Lines 49 to 50 in e4241ca

  	showCloudLogs := true
  	exitOnRunning := false

• loose helper functions like these, that are specific for a single command, can become methods:
  

  k6/cmd/inspect.go

  Line 82 in e4241ca

  func inspectOutputWithExecRequirements(gs *globalState, cmd *cobra.Command, test *loadedTest) (interface{}, error) {

  
  

  k6/cmd/cloud.go

  Line 330 in e4241ca

  func cloudCmdFlagSet(showCloudLogs, exitOnRunning *bool) *pflag.FlagSet {

  
  

  k6/cmd/run.go

  Line 341 in e4241ca

  func handleSummaryResult(fs afero.Fs, stdOut, stdErr io.Writer, result map[string]io.Reader) error {

• this may even decrease the number of instances where we have to pass a bajillion arguments to some constructor function 😅

[na--]

Hmm I had a thought that if globalState was exported and moved to another module (it doesn't really need to be in cmd/ anyway 🤷‍♂️), it would be super easy to allow xk6 extensions to add k6 sub-commands 🤔 Given the cobra architecture, it will even be easy to allow them to mess (e.g. add flags) with other sub-commands...

Still not sure if that is a good or a bad idea though 😅 And even if it's a good idea, it should probably wait for the configuration refactoring (#883), so we don't lock ourselves in the current bad state.