add a output type flag

Author: vinit-chauhan

cmd/filter.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"slices"
 
 	"github.com/spf13/cobra"
 
@@ -33,8 +32,7 @@ func setupFilterCommand() *cobraext.Command {
 	filter.SetFilterFlags(cmd)
 
 	// add the output package name and absolute path flags to the command
-	cmd.Flags().BoolP(cobraext.FilterOutputPackageNameFlagName, "", false, cobraext.FilterOutputPackageNameFlagDescription)
-	cmd.Flags().BoolP(cobraext.FilterOutputAbsolutePathFlagName, "", false, cobraext.FilterOutputAbsolutePathFlagDescription)
+	cmd.Flags().StringP(cobraext.FilterOutputFlagName, cobraext.FilterOutputFlagShorthand, cobraext.FilterOutputFlagDefault, cobraext.FilterOutputFlagDescription)
 
 	return cobraext.NewCommand(cmd, cobraext.ContextPackage)
 }
@@ -45,17 +43,17 @@ func filterCommandAction(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("filtering packages failed: %w", err)
 	}
 
-	printPackageName, err := cmd.Flags().GetBool(cobraext.FilterOutputPackageNameFlagName)
+	outputFormatStr, err := cmd.Flags().GetString(cobraext.FilterOutputFlagName)
 	if err != nil {
-		return fmt.Errorf("getting output package name flag failed: %w", err)
+		return fmt.Errorf("getting output format flag failed: %w", err)
 	}
 
-	outputAbsolutePath, err := cmd.Flags().GetBool("output-absolute-path")
+	outputFormat, err := filter.NewOutputFormat(outputFormatStr)
 	if err != nil {
-		return fmt.Errorf("getting output absolute path flag failed: %w", err)
+		return fmt.Errorf("invalid output format: %w", err)
 	}
 
-	if err = printPkgList(filtered, printPackageName, outputAbsolutePath, os.Stdout); err != nil {
+	if err = printPkgList(filtered, outputFormat, os.Stdout); err != nil {
 		return fmt.Errorf("printing JSON failed: %w", err)
 	}
 
@@ -91,28 +89,14 @@ func filterPackage(cmd *cobra.Command) ([]packages.PackageDirNameAndManifest, er
 	return filtered, nil
 }
 
-func printPkgList(pkgs []packages.PackageDirNameAndManifest, printPackageName bool, outputAbsolutePath bool, w io.Writer) error {
+func printPkgList(pkgs []packages.PackageDirNameAndManifest, outputFormat filter.OutputFormat, w io.Writer) error {
 	enc := json.NewEncoder(w)
 	enc.SetEscapeHTML(false)
-	if len(pkgs) == 0 {
-		return nil
-	}
 
-	names := make([]string, 0, len(pkgs))
-	if printPackageName {
-		for _, pkg := range pkgs {
-			names = append(names, pkg.Manifest.Name)
-		}
-	} else if outputAbsolutePath {
-		for _, pkg := range pkgs {
-			names = append(names, pkg.Path)
-		}
-	} else {
-		for _, pkg := range pkgs {
-			names = append(names, pkg.DirName)
-		}
+	names, err := outputFormat.ApplyTo(pkgs)
+	if err != nil {
+		return fmt.Errorf("applying output format failed: %w", err)
 	}
 
-	slices.Sort(names)
 	return enc.Encode(names)
 }

internal/cobraext/flags.go

@@ -154,8 +154,10 @@ const (
 	FilterOutputAbsolutePathFlagName        = "output-absolute-path"
 	FilterOutputAbsolutePathFlagDescription = "output the absolute path of the package"
 
-	FilterOutputPackageNameFlagName        = "output-package-name"
-	FilterOutputPackageNameFlagDescription = "print the package name instead of the directory name in the output"
+	FilterOutputFlagName        = "output"
+	FilterOutputFlagDescription = "select the output format (pkgname, dirname, absolute-path)"
+	FilterOutputFlagDefault     = "dirname"
+	FilterOutputFlagShorthand   = "o"
 
 	FilterPackageDirNameFlagName        = "package-dirs"
 	FilterPackageDirNameFlagDescription = "package directories to filter by (comma-separated values)"

internal/filter/registry.go

@@ -93,7 +93,6 @@ func (r *FilterRegistry) Execute() (filtered []packages.PackageDirNameAndManifes
 
 	filtered = pkgs
 	for _, filter := range r.filters {
-		logger.Infof("Applying for %d packages", len(filtered))
 		filtered, err = filter.ApplyTo(filtered)
 		if err != nil {
 			errors = append(errors, err)

internal/filter/type.go

@@ -6,12 +6,66 @@ package filter
 
 import (
 	"fmt"
+	"slices"
 
 	"github.com/spf13/cobra"
 
 	"github.com/elastic/elastic-package/internal/packages"
 )
 
+type OutputFormat string
+
+const (
+	OutputFormatPackageName   OutputFormat = "pkgname"
+	OutputFormatDirectoryName OutputFormat = "dirname"
+	OutputFormatAbsolutePath  OutputFormat = "absolute"
+)
+
+func OutputFormatsList() []OutputFormat {
+	return []OutputFormat{OutputFormatPackageName, OutputFormatDirectoryName, OutputFormatAbsolutePath}
+}
+
+func (o OutputFormat) String() string {
+	return string(o)
+}
+
+func NewOutputFormat(s string) (OutputFormat, error) {
+	switch s {
+	case string(OutputFormatPackageName):
+		return OutputFormatPackageName, nil
+	case string(OutputFormatDirectoryName):
+		return OutputFormatDirectoryName, nil
+	case string(OutputFormatAbsolutePath):
+		return OutputFormatAbsolutePath, nil
+	}
+	return "", fmt.Errorf("invalid output format: %s", s)
+}
+
+func (o OutputFormat) ApplyTo(pkgs []packages.PackageDirNameAndManifest) ([]string, error) {
+	// if no packages are found, return an empty slice
+	if len(pkgs) == 0 {
+		return nil, nil
+	}
+
+	// apply the output format to the packages
+	output := make([]string, 0, len(pkgs))
+	for _, pkg := range pkgs {
+		switch o {
+		case OutputFormatPackageName:
+			output = append(output, pkg.Manifest.Name)
+		case OutputFormatDirectoryName:
+			output = append(output, pkg.DirName)
+		case OutputFormatAbsolutePath:
+			output = append(output, pkg.Path)
+		}
+	}
+
+	// sort the output
+	slices.Sort(output)
+
+	return output, nil
+}
+
 // FilterFlag defines the basic interface for filter flags.
 type FilterFlag interface {
 	String() string