kepctl output: extract output logic to pkg/output

Repo seems to be all about CRUD for KEPs. In that context, formatting
output seem like an unrelated concern.

Use an interface/factory pattern to build and use an Output to display
results. Next step: make Query return results, make callers use Output.

Author: spiffxp

pkg/kepctl/commands/query.go

@@ -22,6 +22,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 
+	"k8s.io/enhancements/pkg/output"
 	"k8s.io/enhancements/pkg/repo"
 )
 
@@ -96,10 +97,8 @@ func addQuery(topLevel *cobra.Command) {
 	cmd.PersistentFlags().StringVar(
 		&qo.Output,
 		"output",
-		repo.DefaultOutputOpt,
-		fmt.Sprintf(
-			"Output format. Can be %v", repo.SupportedOutputOpts,
-		),
+		output.DefaultFormat,
+		fmt.Sprintf("Output format. Can be %v", output.ValidFormats()),
 	)
 
 	topLevel.AddCommand(cmd)

pkg/output/output.go

@@ -0,0 +1,237 @@
+/*
+Copyright 2021 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package output
+
+import (
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/olekukonko/tablewriter"
+	"gopkg.in/yaml.v3"
+
+	"k8s.io/enhancements/api"
+)
+
+const (
+	DefaultFormat = "table"
+)
+
+// ValidFormats returns the list of valid formats for NewOutput
+func ValidFormats() []string {
+	return []string{"csv", "json", "table", "yaml"}
+}
+
+// Output is capable of printing... well pretty much just KEPs, but if there
+// is interest in printing other types in api, this could be the place
+type Output interface {
+	PrintProposals([]*api.Proposal)
+}
+
+// output holds out/err streams for Output implementations
+type output struct {
+	Out io.Writer
+	Err io.Writer
+}
+
+// columnOutput holds PrintConfigs in addition to out/err streams for column
+// oriented Output implementations (e.g. CSVOutput)
+type columnOutput struct {
+	output
+	Configs []PrintConfig
+}
+
+// NewOutput returns an Output of the given format that will write to the given
+// out and err Writers, or return an err if the format isn't one of ValidFormats()
+func NewOutput(format string, out, err io.Writer) (Output, error) {
+	switch format {
+	case "json":
+		return &JSONOutput{Out: out, Err: err}, nil
+	case "yaml":
+		return &YAMLOutput{Out: out, Err: err}, nil
+	case "csv":
+		return &CSVOutput{
+			output: output{
+				Out: out,
+				Err: err,
+			},
+			Configs: DefaultPrintConfigs(
+				"Title",
+				"Authors",
+				"SIG",
+				"Stage",
+				"Status",
+				"LastUpdated",
+				"Link",
+			),
+		}, nil
+	case "table":
+		return &TableOutput{
+			output: output{
+				Out: out,
+				Err: err,
+			},
+			Configs: DefaultPrintConfigs(
+				"LastUpdated",
+				"Stage",
+				"Status",
+				"SIG",
+				"Authors",
+				"Title",
+				"Link",
+			),
+		}, nil
+	}
+	return nil, fmt.Errorf("unsupported output format: %s. Valid values: %s", format, ValidFormats())
+}
+
+type YAMLOutput output
+
+// PrintProposals prints KEPs array in YAML format
+func (o *YAMLOutput) PrintProposals(proposals []*api.Proposal) {
+	data, err := yaml.Marshal(proposals)
+	if err != nil {
+		fmt.Fprintf(o.Err, "error printing KEPs as YAML: %s", err)
+		return
+	}
+	fmt.Fprintln(o.Out, string(data))
+}
+
+type JSONOutput output
+
+// PrintProposals prints KEPs array in JSON format
+func (o *JSONOutput) PrintProposals(proposals []*api.Proposal) {
+	data, err := json.Marshal(proposals)
+	if err != nil {
+		fmt.Fprintf(o.Err, "error printing KEPs as JSON: %s", err)
+		return
+	}
+
+	fmt.Fprintln(o.Out, string(data))
+}
+
+type TableOutput columnOutput
+
+// PrintProposals prints KEPs array in table format
+func (o *TableOutput) PrintProposals(proposals []*api.Proposal) {
+	if len(o.Configs) == 0 {
+		return
+	}
+
+	table := tablewriter.NewWriter(o.Out)
+
+	headers := make([]string, 0, len(o.Configs))
+	for _, c := range o.Configs {
+		headers = append(headers, c.Title())
+	}
+
+	table.SetHeader(headers)
+	table.SetAlignment(tablewriter.ALIGN_LEFT)
+
+	for _, k := range proposals {
+		var s []string
+		for _, c := range o.Configs {
+			s = append(s, c.Value(k))
+		}
+		table.Append(s)
+	}
+
+	table.Render()
+}
+
+type CSVOutput columnOutput
+
+// PrintProposals prins KEPs array in CSV format
+func (o *CSVOutput) PrintProposals(proposals []*api.Proposal) {
+	w := csv.NewWriter(o.Out)
+	defer w.Flush()
+
+	headers := make([]string, 0, len(o.Configs))
+	for _, c := range o.Configs {
+		headers = append(headers, c.Title())
+	}
+	if err := w.Write(headers); err != nil {
+		fmt.Fprintf(o.Err, "error printing keps as CSV: %s", err)
+	}
+
+	for _, p := range proposals {
+		var row []string
+		for _, c := range o.Configs {
+			row = append(row, c.Value(p))
+		}
+		if err := w.Write(row); err != nil {
+			fmt.Fprintf(o.Err, "error printing keps as CSV: %s", err)
+		}
+	}
+}
+
+// PrintConfig defines how a given Proposal field should be formatted for
+// columnar output (e.g. TableOutput, CSVOutput)
+type PrintConfig interface {
+	Title() string
+	Value(*api.Proposal) string
+}
+
+type printConfig struct {
+	title     string
+	valueFunc func(*api.Proposal) string
+}
+
+func (p *printConfig) Title() string { return p.title }
+func (p *printConfig) Value(k *api.Proposal) string {
+	return p.valueFunc(k)
+}
+
+func DefaultPrintConfigs(names ...string) []PrintConfig {
+	// TODO: Refactor out anonymous funcs
+	defaultConfig := map[string]printConfig{
+		"Authors":     {"Authors", func(k *api.Proposal) string { return strings.Join(k.Authors, ", ") }},
+		"LastUpdated": {"Updated", func(k *api.Proposal) string { return k.LastUpdated }},
+		"SIG": {"SIG", func(k *api.Proposal) string {
+			if strings.HasPrefix(k.OwningSIG, "sig-") {
+				return k.OwningSIG[4:]
+			}
+
+			return k.OwningSIG
+		}},
+		"Stage":  {"Stage", func(k *api.Proposal) string { return k.Stage }},
+		"Status": {"Status", func(k *api.Proposal) string { return k.Status }},
+		"Title": {"Title", func(k *api.Proposal) string {
+			if k.PRNumber == "" {
+				return k.Title
+			}
+
+			return "PR#" + k.PRNumber + " - " + k.Title
+		}},
+		"Link": {"Link", func(k *api.Proposal) string {
+			if k.PRNumber == "" {
+				return "https://git.k8s.io/enhancements/keps/" + k.OwningSIG + "/" + k.Name
+			}
+
+			return "https://github.com/kubernetes/enhancements/pull/" + k.PRNumber
+		}},
+	}
+	configs := make([]PrintConfig, 0, 10)
+	for _, n := range names {
+		// copy to allow it to be tweaked by the caller
+		c := defaultConfig[n]
+		configs = append(configs, &c)
+	}
+	return configs
+}