[cbuild] Consistent command line options & cleanup

Addressing Open-CMSIS-Pack/devtools#822

The changes include:

1. Undocumented feature to build CPRJ with root command line.
2. Added `buildcprj` command to build `*.cprj` files.
- All build options specific to `*.cprj` build are moved under
`buildcprj `command
3. Removed `list configuration`s command
4. Removed `--configuration` option, instead `-c,--context` can be used
5. `-C` short option for `--clean`
6. `-c, --context` should follow
`[<cproject>][.<build-type>][+<target-type>]`
7. Use lower case small options for `--rebuild` & `--schema` i.e `-r` &
`-s` respectively
8. Use only long options for `--log` & `--update-rte`. As `-L` and `-U
`are reserved for other options in csolution
9. Allow multiple `--context` options

```
$ cbuild.exe -h
cbuild: Build Invocation  (C) 2023 Arm Ltd. and Contributors

Usage:
  cbuild [command] <csolution.yml> [flags]

Available Commands:
  buildcprj   Generate output
  help        Help about any command
  list        List information

Flags:
  -C, --clean              Remove intermediate and output directories
  -c, --context strings    Input context name e.g. project.buildType+targetType
  -d, --debug              Enable debug messages
  -g, --generator string   Select build system generator (default "Ninja")
  -h, --help               Print usage
  -j, --jobs int           Number of job slots for parallel execution
  -l, --load string        Set policy for packs loading [latest|all|required]
      --log string         Save output messages in a log file
  -O, --output string      Set directory for all output files
  -p, --packs              Download missing software packs with cpackget
  -q, --quiet              Suppress output messages except build invocations
  -r, --rebuild            Remove intermediate and output directories and rebuild
  -s, --schema             Validate project input file(s) against schema
  -t, --target string      Optional CMake target name
      --toolchain string   Input toolchain to be used
      --update-rte         Update the RTE directory and files
  -v, --verbose            Enable verbose messages from toolchain builds
  -V, --version            Print version

Use "cbuild [command] --help" for more information about a command.
```

```
$ cbuild.exe buildcprj -h
Generate output

Usage:
  cbuild buildcprj <project.cprj> [flags]

Flags:
  -C, --clean              Remove intermediate and output directories
  -d, --debug              Enable debug messages
  -g, --generator string   Select build system generator (default "Ninja")
  -h, --help               Print usage
  -i, --intdir string      Set directory for intermediate files
  -j, --jobs int           Number of job slots for parallel execution
      --log string         Save output messages in a log file
  -o, --outdir string      Set directory for output binary files
  -p, --packs              Download missing software packs with cpackget
  -q, --quiet              Suppress output messages except build invocations
  -r, --rebuild            Remove intermediate and output directories and rebuild
  -s, --schema             Validate project input file(s) against schema
  -t, --target string      Optional CMake target name
      --toolchain string   Input toolchain to be used
  -u, --update string      Generate *.cprj file for reproducing current build
      --update-rte         Update the RTE directory and files
  -v, --verbose            Enable verbose messages from toolchain builds

```

cmd/cbuild/commands/build/buildcprj.go

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2023 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package build
+
+import (
+	"cbuild/pkg/builder"
+	"cbuild/pkg/builder/cproject"
+	"cbuild/pkg/utils"
+	"errors"
+	"path/filepath"
+
+	"github.com/spf13/cobra"
+)
+
+func BuildCPRJ(cmd *cobra.Command, args []string) error {
+	var inputFile string
+	if len(args) == 1 {
+		inputFile = args[0]
+	} else {
+		_ = cmd.Help()
+		return errors.New("invalid arguments")
+	}
+
+	intDir, _ := cmd.Flags().GetString("intdir")
+	outDir, _ := cmd.Flags().GetString("outdir")
+	lockFile, _ := cmd.Flags().GetString("update")
+	logFile, _ := cmd.Flags().GetString("log")
+	generator, _ := cmd.Flags().GetString("generator")
+	target, _ := cmd.Flags().GetString("target")
+	jobs, _ := cmd.Flags().GetInt("jobs")
+	quiet, _ := cmd.Flags().GetBool("quiet")
+	debug, _ := cmd.Flags().GetBool("debug")
+	verbose, _ := cmd.Flags().GetBool("verbose")
+	clean, _ := cmd.Flags().GetBool("clean")
+	schema, _ := cmd.Flags().GetBool("schema")
+	packs, _ := cmd.Flags().GetBool("packs")
+	rebuild, _ := cmd.Flags().GetBool("rebuild")
+	updateRte, _ := cmd.Flags().GetBool("update-rte")
+	toolchain, _ := cmd.Flags().GetString("toolchain")
+
+	options := builder.Options{
+		IntDir:    intDir,
+		OutDir:    outDir,
+		LockFile:  lockFile,
+		LogFile:   logFile,
+		Generator: generator,
+		Target:    target,
+		Jobs:      jobs,
+		Quiet:     quiet,
+		Debug:     debug,
+		Verbose:   verbose,
+		Clean:     clean,
+		Schema:    schema,
+		Packs:     packs,
+		Rebuild:   rebuild,
+		UpdateRte: updateRte,
+		Toolchain: toolchain,
+	}
+
+	configs, err := utils.GetInstallConfigs()
+	if err != nil {
+		return err
+	}
+
+	params := builder.BuilderParams{
+		Runner:         utils.Runner{},
+		Options:        options,
+		InputFile:      inputFile,
+		InstallConfigs: configs,
+	}
+
+	fileExtension := filepath.Ext(inputFile)
+	var b builder.IBuilderInterface
+	if fileExtension == ".cprj" {
+		b = cproject.CprjBuilder{BuilderParams: params}
+	} else {
+		return errors.New("invalid file argument")
+	}
+
+	//log.Info("Build Invocation " + commands.Version + commands.CopyrightNotice)
+	return b.Build()
+}
+
+var BuildCPRJCmd = &cobra.Command{
+	Use:   "buildcprj <project.cprj> [flags]",
+	Short: "Generate output",
+	Args:  cobra.MinimumNArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return BuildCPRJ(cmd, args)
+	},
+}
+
+func init() {
+	BuildCPRJCmd.Flags().IntP("jobs", "j", 0, "Number of job slots for parallel execution")
+	BuildCPRJCmd.Flags().BoolP("help", "h", false, "Print usage")
+	BuildCPRJCmd.Flags().BoolP("quiet", "q", false, "Suppress output messages except build invocations")
+	BuildCPRJCmd.Flags().BoolP("debug", "d", false, "Enable debug messages")
+	BuildCPRJCmd.Flags().BoolP("verbose", "v", false, "Enable verbose messages from toolchain builds")
+	BuildCPRJCmd.Flags().BoolP("clean", "C", false, "Remove intermediate and output directories")
+	BuildCPRJCmd.Flags().BoolP("packs", "p", false, "Download missing software packs with cpackget")
+	BuildCPRJCmd.Flags().BoolP("rebuild", "r", false, "Remove intermediate and output directories and rebuild")
+	BuildCPRJCmd.Flags().BoolP("update-rte", "", false, "Update the RTE directory and files")
+	BuildCPRJCmd.Flags().BoolP("schema", "s", false, "Validate project input file(s) against schema")
+	BuildCPRJCmd.Flags().StringP("target", "t", "", "Optional CMake target name")
+	BuildCPRJCmd.Flags().StringP("log", "", "", "Save output messages in a log file")
+	BuildCPRJCmd.Flags().StringP("toolchain", "", "", "Input toolchain to be used")
+	BuildCPRJCmd.Flags().StringP("intdir", "i", "", "Set directory for intermediate files")
+	BuildCPRJCmd.Flags().StringP("outdir", "o", "", "Set directory for output binary files")
+	BuildCPRJCmd.Flags().StringP("update", "u", "", "Generate *.cprj file for reproducing current build")
+	BuildCPRJCmd.Flags().StringP("generator", "g", "Ninja", "Select build system generator")
+}

cmd/cbuild/commands/build/buildcprj_test.go

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2023 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package build_test
+
+import (
+	"cbuild/cmd/cbuild/commands"
+	"os"
+	"runtime"
+	"testing"
+
+	cp "github.com/otiai10/copy"
+	log "github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+)
+
+const testRoot = "../../../../test"
+
+func init() {
+	// Prepare test data
+	_ = os.RemoveAll(testRoot + "/run")
+
+	var binExtension string
+	if runtime.GOOS == "windows" {
+		binExtension = ".exe"
+	}
+	cbuildgenBin := testRoot + "/run/bin/cbuildgen" + binExtension
+	file, _ := os.Create(cbuildgenBin)
+	defer file.Close()
+
+	_ = cp.Copy(testRoot+"/run/minimal.cprj", testRoot+"/run/minimal.cprj")
+}
+
+func TestBuildCPRJCommand(t *testing.T) {
+	assert := assert.New(t)
+	os.Setenv("CMSIS_BUILD_ROOT", testRoot+"/run/bin")
+	cprjFile := testRoot + "/run/minimal.cprj"
+
+	t.Run("multiple arguments", func(t *testing.T) {
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile, cprjFile})
+		err := cmd.Execute()
+		assert.Error(err)
+	})
+
+	t.Run("test CPRJ build", func(t *testing.T) {
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile})
+		err := cmd.Execute()
+		assert.Error(err)
+	})
+}
+
+func TestPreLogConfiguration(t *testing.T) {
+	assert := assert.New(t)
+	os.Setenv("CMSIS_BUILD_ROOT", testRoot+"/run/bin")
+	logDir := testRoot + "/run/log"
+	logFile := logDir + "/test.log"
+	cprjFile := testRoot + "/run/minimal.cprj"
+
+	t.Run("test normal verbosity level", func(t *testing.T) {
+		// No quiet, No debug
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile, "-C"})
+		_ = cmd.Execute()
+		assert.Equal(log.InfoLevel, log.GetLevel())
+	})
+
+	t.Run("test quiet verbosity level", func(t *testing.T) {
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile, "--quiet", "-C"})
+		_ = cmd.Execute()
+		assert.Equal(log.ErrorLevel, log.GetLevel())
+	})
+
+	t.Run("test debug debug level", func(t *testing.T) {
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile, "--debug", "-C"})
+		_ = cmd.Execute()
+		assert.Equal(log.DebugLevel, log.GetLevel())
+	})
+
+	t.Run("test invalid path to log file", func(t *testing.T) {
+		os.RemoveAll(logDir)
+
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile, "--log", logFile, "-C"})
+		_ = cmd.Execute()
+		_, err := os.Stat(logFile)
+		assert.True(os.IsNotExist(err))
+	})
+
+	t.Run("test valid path to log file", func(t *testing.T) {
+		_ = os.MkdirAll(logDir, 0755)
+
+		cmd := commands.NewRootCmd()
+		cmd.SetArgs([]string{"buildcprj", cprjFile, "--log", logFile, "-C"})
+		_ = cmd.Execute()
+		_, err := os.Stat(logFile)
+		assert.False(os.IsNotExist(err))
+	})
+}

cmd/cbuild/commands/list/list.go

@@ -26,14 +26,10 @@ func init() {
 		_ = command.Flags().MarkHidden("toolchain")
 		command.Parent().HelpFunc()(command, strings)
 	})
-	ListConfigurationsCmd.SetHelpFunc(func(command *cobra.Command, strings []string) {
-		_ = command.Flags().MarkHidden("toolchain")
-		command.Parent().HelpFunc()(command, strings)
-	})
 	ListEnvironmentCmd.SetHelpFunc(func(command *cobra.Command, strings []string) {
 		_ = command.Flags().MarkHidden("schema")
 		_ = command.Flags().MarkHidden("toolchain")
 		command.Parent().HelpFunc()(command, strings)
 	})
-	ListCmd.AddCommand(ListConfigurationsCmd, ListContextsCmd, ListToolchainsCmd, ListEnvironmentCmd)
+	ListCmd.AddCommand(ListContextsCmd, ListToolchainsCmd, ListEnvironmentCmd)
 }